@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/json/from-csn.js

@@ -68,10 +68,8 @@
  *                                          may not.
  * @property {string}               [xsnOp] Defines the operator to be used for XSN. Used for SET
  *                                          and SELECT. See queryTerm().
- * @property {string|false}      [vZeroFor] Marks the property as a CSN 0.1.0 property. It is
+ * @property {string}            [vZeroFor] Marks the property as a CSN 0.1.0 property. It is
  *                                          replaced by this CSN 1.0 property (value of vZeroFor).
- *                                          "false" indicates that the property may be a v0.1 one
- *                                          which is handled specially, e.g. with "type:vZeroValue"
  * @property {string}         [vZeroIgnore] Marks the property as a CSN 0.1.0 property. The
  *                                          property is ignored and a warning may be issues about
  *                                          it.
@@ -117,13 +115,14 @@ const exprProperties = [
 const xorGroups = {
   // include CSN v0.1.0 properties here:
   ':type': [ 'target', 'elements', 'enum', 'items' ],
-  ':expr': [
-    'ref', 'xpr', 'list', 'val', '#', 'func', 'SELECT', 'SET',
+  ':expr': [                    // see also xorException property in schema
+    'ref', 'xpr', 'list', 'val', '#', 'func', 'SELECT', 'SET', 'expand',
     '=', 'path', 'value', 'op', // '='/'path' is CSN v0.1.0 here
   ],
   ':ext': [ 'annotate', 'extend' ], // TODO: better msg for test/negative/UnexpectedProperties.csn
   ':assoc': [ 'on', 'keys', 'foreignKeys', 'onCond' ], // 'foreignKeys'/'onCond' is CSN v0.1.0
-  ':join': [ 'join', 'as' ],
+  // TODO - improve consequential errors: assume no name given with `join` or `inline`?
+  as: [ 'as', 'join', 'inline' ],
   scope: [ 'param', 'global' ],
   quantifier: [ 'some', 'any', 'distinct', 'all' ],
   // quantifiers 'some' and 'any are 'xpr' token strings in CSN v1.0
@@ -137,7 +136,7 @@ const schemaClasses = {
   condition: {
     arrayOf: exprOrString,
     type: condition,
-    msgId: 'syntax-expected-term',
+    msgId: 'syntax-expecting-term',
     // TODO: also specify requires here, and adapt onlyWith()
     optional: exprProperties,
   },
@@ -147,19 +146,20 @@ const schemaClasses = {
   },
   natnumOrStar: {
     type: natnumOrStar,
-    msgId: 'syntax-expected-cardinality',
+    msgId: 'syntax-expecting-cardinality',
   },
   columns: {
     arrayOf: selectItem,
-    msgId: 'syntax-expected-column',
+    msgId: 'syntax-expecting-column',
     defaultKind: '$column',
     validKinds: [], // pseudo kind '$column'
     // A column with only as+cast.type is a new association
-    requires: [ 'ref', 'as', 'xpr', 'val', '#', 'func', 'list', 'SELECT', 'SET', 'expand' ],
+    requires: [ 'ref', 'cast', 'xpr', 'val', '#', 'func', 'list', 'SELECT', 'SET', 'expand' ],
     schema: {
       xpr: {
         class: 'condition',
         type: xprInValue,
+        xorException: 'func',   // see xorGroup :expr
         inKind: [ '$column' ],
         inValue: true,
       },
@@ -248,10 +248,12 @@ const schema = compileSchema( {
   },
   expand: {
     class: 'columns',
-    inKind: [ '$column' ], // only valid in $column
+    xorException: 'ref',        // see xorGroup :expr
+    inKind: [ '$column' ],      // only valid in $column
   },
   inline: {
     class: 'columns',
+    onlyWith: 'ref',
     inKind: [ '$column' ], // only valid in $column
   },
   keys: {
@@ -292,17 +294,21 @@ const schema = compileSchema( {
   // type properties (except: elements, enum, keys, on): ---------------------
   type: {
     type: artifactRef,
-    msgId: 'syntax-expected-reference',
+    msgId: 'syntax-expecting-reference',
     optional: [ 'ref', 'global' ],
-    inKind: [ 'element', 'type', 'param', 'mixin', 'event', 'annotation' ],
+    inKind: [ 'element', 'type', 'param', 'mixin', 'event', 'annotation', 'extend' ],
   },
   targetAspect: {
     type: artifactRef,
+    msgId: 'syntax-expecting-reference',
+    requires: 'elements',
     optional: [ 'elements' ], // 'elements' for ad-hoc aspect compositions
     inKind: [ 'element', 'type' ],
   },
   target: {
     type: artifactRef,
+    msgId: 'syntax-expecting-reference',
+    requires: 'elements',
     optional: [ 'elements' ], // 'elements' for ad-hoc COMPOSITION OF (gensrc style CSN)
     inKind: [ 'element', 'type', 'mixin', 'param' ],
   },
@@ -323,20 +329,20 @@ const schema = compileSchema( {
   },
   length: {
     type: natnum,
-    inKind: [ 'element', 'type', 'param', 'annotation' ],
+    inKind: [ 'element', 'type', 'param', 'annotation', 'extend' ],
     // we do not require a 'type', too - could be useful alone in a 'cast'
   },
   precision: {
     type: natnum,
-    inKind: [ 'element', 'type', 'param', 'annotation' ],
+    inKind: [ 'element', 'type', 'param', 'annotation', 'extend' ],
   },
   scale: {
     type: scalenum,
-    inKind: [ 'element', 'type', 'param', 'annotation' ],
+    inKind: [ 'element', 'type', 'param', 'annotation', 'extend' ],
   },
   srid: {
     type: natnum,
-    inKind: [ 'element', 'type', 'param', 'annotation' ],
+    inKind: [ 'element', 'type', 'param', 'annotation' ], // no 'extend'!
   },
   srcmin: {                        // in 'cardinality'
     type: renameTo( 'sourceMin', natnum ),
@@ -368,10 +374,11 @@ const schema = compileSchema( {
   ref: {
     arrayOf: refItem,
     type: renameTo( 'path', arrayOf( refItem ) ),
-    msgId: 'syntax-expected-reference',
+    msgId: 'syntax-expecting-reference',
     minLength: 1,
     requires: 'id',
     optional: [ 'id', 'args', 'cardinality', 'where' ],
+    xorException: 'expand',     // see xorGroup :expr
     inKind: [ '$column', 'key' ],
   },
   id: {                         // in 'ref' item
@@ -389,6 +396,7 @@ const schema = compileSchema( {
   },
   func: {
     type: func,
+    xorException: 'xpr',       // see xorGroup :expr
     inKind: [ '$column' ],
   },
   args: {
@@ -405,6 +413,7 @@ const schema = compileSchema( {
   xpr: {
     class: 'condition',
     type: xpr,
+    xorException: 'func',       // see xorGroup :expr
     // special treatment in $column
   },
   list: {
@@ -631,14 +640,13 @@ const schema = compileSchema( {
   origin: {                     // old-style CSN
     type: vZeroDelete, ignore: true,
   },
-  source: {                     // CSN v0.1.0 query not supported
+  source: {                     // CSN v0.1.0 query not supported (is error)
     type: ignore,
   },
   value: {
-    vZeroFor: false,                // CSN v0.1.0 property, but handled specially
-    type: vZeroValue,
-    optional: exprProperties,
-    inKind: [ '$column', 'enum' ],
+    vZeroFor: 'val',             // CSN v0.1.0 property for `val` in enum def
+    type: annoValue,
+    // inKind: [ 'enum' ],
   },
   // ignored: ----------------------------------------------------------------
   $location: {                  // special
@@ -747,6 +755,7 @@ function compileSchema( specs, proto = null) {
   }
   if (proto)
     return r;
+  // Set property 'inValue' in main schema only:
   for (const prop of exprProperties) {
     if (r[prop].inValue === undefined)
       r[prop].inValue = true;
@@ -772,8 +781,8 @@ function arrayOf( fn, filter = undefined ) {
     } );
     const minLength = spec.minLength || 0;
     if (minLength > val.length) {
-      message( 'syntax-expected-length', location(true),
-               { prop: spec.prop, n: minLength, '#': minLength === 1 ? 'one' : 'std' });
+      error( 'syntax-incomplete-array', location(true),
+             { prop: spec.prop, n: minLength, '#': minLength === 1 ? 'one' : 'std' });
     }
     if (val.length)
       ++virtualLine;          // [] in one JSON line
@@ -842,20 +851,8 @@ function object( obj, spec ) {
   if (requires === undefined || requires === true) {
     // console.log(csnProps,JSON.stringify(spec))
     if (!relevantProps) {
-      error( 'syntax-required-subproperty', location(true),
-             {
-               prop: spec.msgProp,
-               '#': (
-                 // eslint-disable-next-line no-nested-ternary
-                 !csnProps.length ? 'std'
-                   : csnProps.length === 1 && csnProps[0] === 'as' ? 'as'
-                     : 'relevant'),
-             },
-             {
-               std: 'Object in $(PROP) must have at least one property',
-               as: 'Object in $(PROP) must have at least one property other than \'as\'',
-               relevant: 'Object in $(PROP) must have at least one relevant property',
-             } );
+      error( 'syntax-incomplete-object', location(true),
+             { '#': (obj.as != null ? 'as' : 'std'), prop: spec.msgProp, otherprop: 'as' } );
     }
   }
   else if (requires) {
@@ -868,10 +865,10 @@ function object( obj, spec ) {
 
 function vZeroDelete( o, spec ) { // for old-CSN property 'origin'
   if (!csnVersionZero) {
-    warning( 'syntax-zero-delete', location(true), { prop: spec.msgProp },
-             'Delete/inline CSN v0.1.0 property $(PROP)' );
+    warning( 'syntax-deprecated-property', location(true),
+             { '#': 'zero', prop: spec.msgProp } );
   }
-  string( o, spec );
+  ignore( o );
 }
 
 // Definitions, dictionaries and arrays of definitions (std signature) -------
@@ -881,7 +878,7 @@ function definition( def, spec, xsn, csn, name ) {
     return {
       kind: (inExtensions ? 'annotate' : spec.defaultKind),
       name: {
-        id: '', path: [], absolute: name, location: location(),
+        id: '', path: [], absolute: name || '', location: location(),
       },
       location: location(),
     };
@@ -914,7 +911,6 @@ function definition( def, spec, xsn, csn, name ) {
       r.name.$inferred = 'as';
     // TODO the following 'if' (if necessary) should be part of the core compiler
     if (prop === 'definitions' || prop === 'vocabularies') { // as spec property
-      // xsn.name.path = name.split('.').map( id => ({ id, location: location() }) );
       r.name = {
         absolute: name,
         id: name.substring( name.lastIndexOf('.') + 1 ),
@@ -953,7 +949,7 @@ function definition( def, spec, xsn, csn, name ) {
 function dictionaryOf( elementFct ) {
   return function dictionary( dict, spec ) {
     if (!dict || typeof dict !== 'object' || Array.isArray( dict )) {
-      error( 'syntax-expected-object', location(true),
+      error( 'syntax-expecting-object', location(true),
              { prop: spec.prop }); // spec.prop, not spec.msgProp!
       return ignore( dict );
     }
@@ -965,9 +961,8 @@ function dictionaryOf( elementFct ) {
     ++virtualLine;
     for (const name of allNames) {
       if (!name) {
-        warning( 'syntax-empty-name', location(true),
-                 { prop: spec.prop }, // TODO: Error
-                 'Property names in dictionary $(PROP) must not be empty' );
+        warning( 'syntax-invalid-name', location(true), // TODO: Error
+                 { '#': 'csn', parentprop: spec.prop } );
       }
       const val = elementFct( dict[name], spec, r, dict, name );
       if (val !== undefined)
@@ -1042,9 +1037,11 @@ function validKind( val, spec, xsn ) {
   if (val === xsn.kind)         // has been set in definition - the same = ok!
     return undefined;           // already set in definition
   if (val === 'view' && xsn.kind === 'entity') {
-    warning( 'syntax-zero-value', location(true), { prop: spec.msgProp },
-             'Replace CSN v0.1.0 value in $(PROP) by something specified' );
+    warning( 'syntax-deprecated-value', location(true),
+             { '#': 'replace', prop: spec.msgProp, value: 'entity' } );
   }
+  // TODO: rather issue info at `abstract` and `$syntax`, i.e. current location is strange
+  // change message id in a later change
   else if ((val === 'entity' || val === 'type') && xsn.kind === 'aspect') {
     info( 'syntax-aspect', location(true), { kind: 'aspect', '#': val },
           {
@@ -1054,8 +1051,8 @@ function validKind( val, spec, xsn ) {
           } );
   }
   else {
-    error( 'syntax-expected-valid', location(true), { prop: spec.msgProp },
-           'Expected valid string for property $(PROP)' );
+    error( 'syntax-invalid-kind', location(true), { prop: spec.msgProp },
+           'Invalid value for property $(PROP)' );
   }
   return ignore( val );
 }
@@ -1063,12 +1060,16 @@ function validKind( val, spec, xsn ) {
 function artifactRef( ref, spec ) {
   if (!ref || typeof ref !== 'string')
     return object( ref, spec );
-  if (spec.prop !== 'type' || !csnVersionZero)
+  if (spec.prop !== 'type')
     return stringRef( ref, spec );
-  // now the CSN v0.1.0 type of: 'Artifact..e1.e2'
+  // now the CSN v0.1.0 type of: 'Artifact..e1.e2'; error if not csnVersionZero
   const idx = ref.indexOf('..');
   if (idx < 0)
     return stringRef( ref, spec );
+  if (!csnVersionZero) {
+    warning( 'syntax-deprecated-value', location(true),
+             { '#': 'zero-replace', prop: spec.msgProp, value: '{ ref: […] }' } );
+  }
   const r = refSplit( ref.substring( idx + 2 ), spec.msgProp );
   r.path.unshift( { id: ref.substring( 0, idx ), location: location() } );
   return r;
@@ -1095,9 +1096,9 @@ function vZeroRef( name, spec, xsn ) {
   if (!string( name, spec ))
     return;
   const path = name.split('.');
-  if (!path.every( id => id)) {
-    warning( 'syntax-expected-name', location(true), { prop: spec.msgProp },
-             'Expected correct name for property $(PROP)' );
+  if (!path.every( id => id)) { // TODO: why just warning?
+    warning( 'syntax-invalid-zero-ref', location(true), { prop: spec.msgProp },
+             'Invalid string reference in property $(PROP)' );
   }
   xsn.path = path.map( id => ({ id, location: location() }) );
 }
@@ -1107,18 +1108,17 @@ function vZeroRef( name, spec, xsn ) {
 function boolOrNull( val, spec ) {
   if ([ true, false, null ].includes( val ))
     return { val, location: location() };
-  warning( 'syntax-expected-boolean', location(true), { prop: spec.msgProp },
-           'Expected boolean or null for property $(PROP)' );
+  warning( 'syntax-expecting-boolean', location(true), { prop: spec.msgProp },
+           'Expecting boolean or null for property $(PROP)' );
   ignore( val );
   return { val: !!val, location: location() };
 }
 
 function string( val, spec ) {
   if (typeof val === 'string' && val)
-    //  XSN TODO: do not require literal
     return val;
-  error( 'syntax-expected-string', location(true), { prop: spec.msgProp },
-         'Expected non-empty string for property $(PROP)' );
+  error( 'syntax-expecting-string', location(true), { prop: spec.msgProp },
+         'Expecting non-empty string for property $(PROP)' );
   return ignore( val );
 }
 
@@ -1126,8 +1126,8 @@ function stringVal( val, spec ) {
   if (typeof val === 'string' && val)
     //  XSN TODO: do not require literal
     return { val, literal: 'string', location: location() };
-  error( 'syntax-expected-string', location(true), { prop: spec.msgProp },
-         'Expected non-empty string for property $(PROP)' );
+  error( 'syntax-expecting-string', location(true), { prop: spec.msgProp },
+         'Expecting non-empty string for property $(PROP)' );
   return ignore( val );
 }
 
@@ -1148,7 +1148,7 @@ function natnum( val, spec ) {
   if (typeof val === 'number' && val >= 0)
     //  XSN TODO: do not require literal
     return { val, literal: 'number', location: location() };
-  error( spec.msgId || 'syntax-expected-natnum', location(true),
+  error( spec.msgId || 'syntax-expecting-natnum', location(true),
          { prop: spec.msgProp } );
   return ignore( val );
 }
@@ -1183,18 +1183,19 @@ function annoValue( val, spec ) {
     /** @type {string|boolean} */
     let seenEllipsis = false;
     if (arrayLevelCount > 0) {  // TODO: also inside structure (possible in CSN!)
-      if (val.some( isEllipsis ))
-        error( 'syntax-unexpected-ellipsis', location(true), { '#': 'nested-array', code: '...' } );
+      if (val.some( isEllipsis )) { // remark: check is via parsing rules in CDL
+        error( 'syntax-unexpected-ellipsis', location(true),
+               { '#': 'csn-nested', prop: '...' } );
+      }
     }
     else {
       for (const item of val) {
-        if (seenEllipsis !== true) {
+        if (seenEllipsis !== true) { // no `...` yet, or only `... up to`
           seenEllipsis = isEllipsis( item ) || seenEllipsis;
         }
-        else if (isEllipsis( item )) { // with or without UP TO
-          // error position at the beginning of the array, but that is fine
-          error( 'syntax-duplicate-ellipsis', location(true), { code: '...' },
-                 'Expected no more than one $(CODE)' );
+        else if (isEllipsis( item )) { // `...`with or without UP TO
+          error( 'syntax-unexpected-ellipsis', location(true),
+                 { '#': 'csn-duplicate', prop: '...', code: '{ "...": true }' } );
           break;
         }
       }
@@ -1207,10 +1208,8 @@ function annoValue( val, spec ) {
     };
     arrayLevelCount--;
     if (seenEllipsis === 'upTo') {
-      error( 'syntax-expecting-ellipsis', location(true), // at closing bracket
-             { code: '... up to', newcode: '...' },
-             // TODO: should we be more CSN specific in the message?
-             'Expecting an array item $(NEWCODE) after an item with $(CODE)' );
+      error( 'syntax-missing-ellipsis', location(true), // at closing bracket
+             { code: '{ "...": ‹up to value› }', newcode: '{ "...": true }' } );
     }
     return retval;
   }
@@ -1226,8 +1225,10 @@ function annoValue( val, spec ) {
   }
   else if (typeof val['='] === 'string') {
     if (Object.keys( val ).length === 1) {
-      virtualLine += 2;
-      return refSplit( val['='], '=' );
+      ++virtualLine;
+      const r = refSplit( val['='], '=' );
+      ++virtualLine;
+      return r;
     }
   }
   else if (val['...'] && Object.keys( val ).length === 1) {
@@ -1276,26 +1277,29 @@ function value( val, spec, xsn ) { // for CSN property 'val'
       xsn.literal = (val === null) ? 'null' : typeof val;
     return val;
   }
-  error( 'syntax-expected-scalar', location(true), { prop: spec.msgProp },
+  error( 'syntax-expecting-scalar', location(true), { prop: spec.msgProp },
          'Only scalar values are supported for property $(PROP)' );
   return ignore( val );
 }
 
 function literal( lit, spec, xsn, csn ) {
   // TODO: general: requires other property (here: 'val')
+  if (!string( lit ))
+    return undefined;
   const type = (csn.val == null) ? 'null' : typeof csn.val;
   if (lit === type)            // also for 'object' which is an error for 'val'
     return lit;
-  if (typeof lit === 'string' && quotedLiteralPatterns[lit]?.json_type === type) {
-    const p = quotedLiteralPatterns[lit];
+  const p = quotedLiteralPatterns[lit];
+  if (p?.json_type === type) {
+    // TODO: wrong position, we complain about the format here, that is in 'val',
+    // TODO: make it then also more CSN-specific?  Next change
     if (p && p.test_fn && !p.test_fn(csn.val))
       warning( 'syntax-invalid-literal', location(), { '#': p.test_variant } );
     return lit;
   }
   if (lit === 'number' && type === 'string') // special case, not a quoted literal in CDL
     return lit;
-  error( 'syntax-expected-valid', location(true), { prop: spec.msgProp },
-         'Expected valid string for property $(PROP)' );
+  error( 'syntax-invalid-string', location(true), { prop: spec.msgProp } );
   return ignore( lit );
 }
 
@@ -1309,8 +1313,8 @@ function func( val, spec, xsn ) {
 function xpr( exprs, spec, xsn, csn ) {
   if (csn.func) {
     if (!exprs.length) {
-      message( 'syntax-expected-length', location(true),
-               { prop: 'xpr', otherprop: 'func', '#': 'suffix' });
+      error( 'syntax-incomplete-array', location(true),
+             { prop: 'xpr', siblingprop: 'func', '#': 'suffix' });
     }
     xsn.suffix = exprArgs( exprs, spec );
   }
@@ -1342,9 +1346,9 @@ function args( exprs, spec ) {
     return arrayOf( exprOrString )( exprs, spec );
   }
   else if (!exprs || typeof exprs !== 'object') {
-    error( 'syntax-expected-args', location(true),
+    error( 'syntax-expecting-args', location(true),
            { prop: spec.prop }, // spec.prop, not spec.msgProp!
-           'Expected array or object for property $(PROP)' );
+           'Expecting array or object for property $(PROP)' );
     return ignore( exprs );
   }
   const r = Object.create(null);
@@ -1362,16 +1366,24 @@ function args( exprs, spec ) {
 }
 
 function expr( e, spec ) {
-  if (Array.isArray( e ) && e.length === 1) {
-    replaceZeroValue( spec );
+  if (Array.isArray( e ) && e.length === 1) { // CSN v.0.1.0 way for parentheses
+    const loc = location();
+    if (e[0] && !e[0].op)       // do not complain with 'op' (for which we complain)
+      replaceZeroValue( spec, 'zero-parens' );
     ++virtualLine;
     const r = expr( e[0], spec );
+    if (!r)
+      return r;
+    if (r.$parens)
+      r.$parens.push( loc );
+    else
+      r.$parens = [ loc ];
     ++virtualLine;
-    return [ r || { location: location() } ];
+    return r;
   }
   else if (e === null || [ 'string', 'number', 'boolean' ].includes( typeof e )) {
     //  && spec.optional.includes( 'val' )) ?
-    replaceZeroValue( spec );
+    replaceZeroValue( spec, 'zero-replace', '{ val: ‹value› }' );
     return annoValue( e, spec );
   }
   return object( e, spec );
@@ -1402,20 +1414,6 @@ function condition( cond, spec ) {
   };
 }
 
-function vZeroValue( obj, spec, xsn ) {
-  if (xsn.value) {
-    // TODO: also "sign" xsn.value created by inValue to complain about both 'value' and 'ref' etc
-    warning( 'syntax-unexpected-property', location(true), { prop: spec.msgProp },
-             'Unexpected CSN property $(PROP)' );
-    return undefined;
-  }
-  if (!csnVersionZero) {
-    warning( 'syntax-zero-delete', location(true), { prop: spec.msgProp },
-             'Delete/inline CSN v0.1.0 property $(PROP)' );
-  }
-  return expr( obj, spec );
-}
-
 // Queries (std signature) ---------------------------------------------------
 
 function queryTerm( term, spec, xsn ) { // for CSN properties 'SELECT' and 'SET'
@@ -1457,17 +1455,16 @@ function excluding( array, spec, xsn ) {
   xsn.excludingDict = r;
 }
 
-function masked( val, spec ) {
-  message('syntax-invalid-masked', location(), { keyword: 'masked' },
-          'Keyword $(KEYWORD) not supported');
-  return boolOrNull( val, spec );
-}
-
 function duplicateExcluding( name, loc ) {
-  error( 'duplicate-excluding', loc, { name, keyword: 'excluding' },
+  error( 'syntax-duplicate-excluding', loc, { name, keyword: 'excluding' }, // TODO: also CDL
          'Duplicate $(NAME) in the $(KEYWORD) clause' );
 }
 
+function masked( val, spec ) {
+  message( 'syntax-unsupported-masked', location(), { '#': 'csn', prop: 'masked' } );
+  return boolOrNull( val, spec );
+}
+
 function setOp( val, spec ) { // UNION, ...
   // similar to string(), but without literal
   return string( val, spec ) && { val, location: location() };
@@ -1483,9 +1480,10 @@ function join( val, spec, xsn ) {
 
 function queryArgs( val, spec, xsn, csn ) {
   if (Array.isArray( val ) && val.length > 1 && !csn.op) {
-    warning( 'syntax-expected-property', location(true),
-             { prop: 'args', otherprop: 'op' },
-             'CSN property $(PROP) expects property $(OTHERPROP) to be specified' );
+    // Make it error 'syntax-missing-property#sibling' in v4:
+    warning( 'syntax-deprecated-auto-union', location(true),
+             { siblingprop: 'args', prop: 'op' },
+             'Object with property $(SIBLINGPROP) must also have a property $(PROP)' );
     xsn.op = { val: 'union', location: location() };
   }
   return arrayOf( object )( val, spec ).map( q => q.query );
@@ -1502,9 +1500,9 @@ function i18nLang( val, spec, xsn, csn, langKey ) {
 function translations( keyVal, spec, xsn, csn, textKey ) {
   if (typeof keyVal === 'string') // allow empty string
     return { val: keyVal, literal: 'string', location: location() };
-  error( 'syntax-expected-translation', location(true),
-         { prop: textKey, otherprop: spec.prop },
-         'Expected string for text key $(PROP) of language $(OTHERPROP)' );
+  error( 'syntax-expecting-translation', location(true),
+         { prop: textKey, language: spec.prop },
+         'Expecting string for text key $(PROP) of language $(LANGUAGE)' );
   return ignore( keyVal );
 }
 
@@ -1514,21 +1512,18 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
   const p0 = schema[prop] ? prop : prop.charAt(0);
   const s = (parentSpec.schema || schema)[p0];
   if (!s || s.noPrefix && prop !== p0 ) {
-    if (ourpropsRegex.test( prop )) {
-      // TODO v2: Warning only with --sloppy
-      warning( 'syntax-unknown-property', location(true), { prop },
-               'Unknown CSN property $(PROP)' );
-    }
-    else {                      // TODO v2: always (i.e. also with message) add to $extra
+    if (!ourpropsRegex.test( prop ))
       return { prop, type: extra };
-    }
+    // TODO v4: No warning with --sloppy
+    warning( 'syntax-unknown-property', location(true), { prop },
+             'Unknown CSN property $(PROP)' );
+    return { type: ignore };
   }
   else if (!expected( p0, s )) {
     if (s.ignore)
       return { type: ignore };
     if (s.vZeroIgnore && s.vZeroIgnore === csn[prop]) { // for "op": "call"
-      warning( 'syntax-zero-delete', location(true), { prop },
-               'Delete/inline CSN v0.1.0 property $(PROP)' );
+      warning( 'syntax-deprecated-property', location(true), { '#': 'zero', prop } );
       return { type: ignore };
     }
     const zero = s.vZeroFor;
@@ -1544,22 +1539,18 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
     }
     // eslint-disable-next-line no-nested-ternary
     const variant = kind && s.inKind
-      ? ([ 'extend', 'annotate' ].includes(kind) ? kind : 'def')
-      : (parentSpec.msgProp ? 'std' : 'top');
+      ? ([ 'extend', 'annotate' ].includes(kind) ? kind : 'kind')
+      : (parentSpec.msgProp ? 'prop' : 'top');
     message( 'syntax-unexpected-property', location(true),
              {
-               prop, otherprop: parentSpec.msgProp, kind, '#': variant,
-             },
-             {
-               std: 'CSN property $(PROP) is not expected in $(OTHERPROP)',
-               top: 'CSN property $(PROP) is not expected top-level',
-               def: 'CSN property $(PROP) is not expected by a definition of kind $(KIND)',
-               extend: 'CSN property $(PROP) is not expected by an extend in $(OTHERPROP)',
-               annotate: 'CSN property $(PROP) is not expected by an annotate in $(OTHERPROP)',
+               '#': variant,
+               prop,
+               parentprop:
+               parentSpec.msgProp,
+               kind,
              } );
-    // TODO: or still augment it? (but then also handle xorGroup)
   }
-  else if (checkAndSetXorGroup( s.xorGroup, prop, xor )) {
+  else if (checkAndSetXorGroup( s.xorGroup, s.xorException, prop, xor )) {
     onlyWith( s, s.onlyWith, csn, prop, xor, expected );
     return s;
   }
@@ -1604,37 +1595,34 @@ function onlyWith( spec, need, csn, prop, xor, expected ) {
     need = allowed.find( p => !xor[schema[p].xorGroup] ) || allowed[0];
   }
   if (prop) {
-    error( 'syntax-dependent-property', location(true),
-           { prop, otherprop: need },
-           'CSN property $(PROP) can only be used in combination with $(OTHERPROP)');
+    error( 'syntax-missing-property', location(true), // location at $(PROP)
+           { '#': 'sibling', prop: need, siblingprop: prop } );
     xor['no:req'] = prop;
   }
+  // TODO: does no:req work? check test3/NestedProjections/Basics/SyntaxErrorsCsn.err.csn
   else if (!xor['no:req']) {
-    error( 'syntax-required-property', location(true),
-           { prop: need, otherprop: spec.msgProp, '#': spec.prop },
-           {  // TODO $(PARENT), TODO: do not use prop===0 hack
-             std: 'Object in $(OTHERPROP) must have the property $(PROP)',
-             columns: 'Object in $(OTHERPROP) must have an expression property like $(PROP)',
-             // eslint-disable-next-line max-len
-             extensions: 'Object in $(OTHERPROP) must have the property \'annotate\' or \'extend\'',
+    error( 'syntax-missing-property', location(true), // TODO: re-check columns, expand, inline
+           {
+             '#': spec.prop,
+             prop: need,
+             parentprop: spec.msgProp,
+             otherprop: 'annotate',
            } );
   }
   return spec;
 }
 
-function checkAndSetXorGroup( group, prop, xor ) {
+function checkAndSetXorGroup( group, exception, prop, xor ) {
   if (!group)
     return true;
-  if (!xor[group]) {
+  const siblingprop = xor[group];
+  if (!siblingprop) {
     xor[group] = prop;
     return true;
   }
-  if (prop === 'func' && xor[group] === 'xpr' ||
-      prop === 'xpr' && xor[group] === 'func')
-    return true;                // hack for window function: both func and xpr is allowed
-  error( 'syntax-excluded-property', location(true),
-         { prop, otherprop: xor[group] },
-         'CSN property $(PROP) can only be used alternatively to $(OTHERPROP)');
+  if (siblingprop === exception)
+    return true;
+  message( 'syntax-unexpected-property', location(true), { '#': 'sibling', prop, siblingprop } );
   return false;
 }
 
@@ -1644,11 +1632,11 @@ function implicitName( ref ) {
   return (typeof item === 'object') ? item && item.id : item;
 }
 
-function replaceZeroProp( otherprop, prop ) {
+function replaceZeroProp( prop, otherprop ) {
   if (csnVersionZero)
     return;
-  warning( 'syntax-zero-prop', location(true), { prop, otherprop },
-           'Replace CSN v0.1.0 property $(OTHERPROP) by $(PROP)' );
+  warning( 'syntax-deprecated-property', location(true),
+           { '#': 'zero-replace', prop, otherprop } );
 }
 
 // Other helper functions, locations -----------------------------------------
@@ -1656,15 +1644,15 @@ function replaceZeroProp( otherprop, prop ) {
 function isArray( array, spec ) {
   if (Array.isArray( array ))
     return array;
-  error( 'syntax-expected-array', location(true), { prop: spec.prop },
-         'Expected array for property $(PROP)' );
+  error( 'syntax-expecting-array', location(true), { prop: spec.prop },
+         'Expecting array for property $(PROP)' );
   return ignore( array );
 }
 
 function isObject( obj, spec ) {
   if (obj && typeof obj === 'object' && !Array.isArray( obj ))
     return obj;
-  error( spec.msgId || 'syntax-expected-object', location(true),
+  error( spec.msgId || 'syntax-expecting-object', location(true),
          { prop: spec.msgProp });
   return ignore( obj );
 }
@@ -1672,16 +1660,16 @@ function isObject( obj, spec ) {
 function refSplit( name, prop ) {
   const path = name.split('.');
   if (!path.every( id => id)) {
-    warning( 'syntax-expected-name', location(true), { prop },
-             'Expected correct name for property $(PROP)' );
+    warning( 'syntax-expecting-name', location(true), { prop }, // TODO: re-check
+             'Expecting correct name for property $(PROP)' );
   }
   return { path: path.map( id => ({ id, location: location() }) ), location: location() };
 }
 
-function replaceZeroValue( spec ) {
-  if (!csnVersionZero && spec.vZeroFor == null) { // but 0 does not match!
-    warning( 'syntax-zero-value', location(true), { prop: spec.msgProp },
-             'Replace CSN v0.1.0 value in $(PROP) by something specified' );
+function replaceZeroValue( spec, msgid, otherprop ) {
+  if (!csnVersionZero && !spec.vZeroFor) {
+    warning( 'syntax-deprecated-value', location(true),
+             { '#': msgid, prop: spec.msgProp, otherprop } );
   }
 }
 
@@ -1710,7 +1698,7 @@ function pushLocation( obj ) {
   else if (!loc || typeof loc !== 'string') {
     if (loc)
       dollarLocations.push( null ); // must match with popLocation()
-    error( 'syntax-expected-object', location(true), { prop: '$location' } );
+    error( 'syntax-expecting-object', location(true), { prop: '$location' } );
   }
   // hidden feature: string $location
   const m = /:(\d+)(?::(\d+))?$/.exec( loc ); // extra '^'s at end deliberately left out
@@ -1767,7 +1755,7 @@ function toXsn( csn, filename, options, messageFunctions ) {
   ({ message, error, warning, info } = messageFunctions);
 
   if (csnVersionZero) {
-    warning( 'syntax-csn-zero-version', location(true),
+    warning( 'syntax-deprecated-csn-version', location(true), {},
              'Parsing CSN version 0.1.0' );
   }
   const r = object( csn, topLevelSpec );
@@ -1823,7 +1811,8 @@ function parse( source, filename = 'csn.json', options = {}, messageFunctions =
       line,
       col: column,
     };
-    messageFunctions.error( 'syntax-illegal-json', loc, { msg }, 'Illegal JSON: $(MSG)' );
+    messageFunctions.error( 'syntax-invalid-json', loc, { msg },
+                            'Invalid JSON: $(MSG)' );
     return xsn;
   }
 }