@sap/cds-compiler 6.8.0 → 6.9.0

package/lib/gen/Dictionary.json

@@ -170,6 +170,8 @@
       "Type": "Core.Tag"
     },
     "Capabilities.BatchContinueOnErrorSupported": {
+      "$deprecated": true,
+      "$deprecationText": "Deprecated in favor of the [`ContinueOnErrorSupported`](#BatchSupportType) property from the [`BatchSupport`](#BatchSupport) term",
       "AppliesTo": [
         "EntityContainer"
       ],
@@ -1167,13 +1169,15 @@
     },
     "Communication.IsEmailAddress": {
       "AppliesTo": [
-        "Property"
+        "Property",
+        "Parameter"
       ],
       "Type": "Core.Tag"
     },
     "Communication.IsPhoneNumber": {
       "AppliesTo": [
-        "Property"
+        "Property",
+        "Parameter"
       ],
       "Type": "Core.Tag"
     },
@@ -1863,7 +1867,6 @@
           }
         }
       },
-      "$experimental": true,
       "AppliesTo": [
         "Property",
         "Parameter"
@@ -2106,7 +2109,8 @@
     "UI.Placeholder": {
       "AppliesTo": [
         "Property",
-        "Parameter"
+        "Parameter",
+        "Record"
       ],
       "Type": "Edm.String"
     },
@@ -2145,7 +2149,11 @@
       "AppliesTo": [
         "EntityType"
       ],
-      "Type": "Edm.ComplexType"
+      "DerivedTypeConstraint": [
+        "Edm.ComplexType",
+        "Edm.EntityType"
+      ],
+      "Type": "Edm.Untyped"
     },
     "UI.SelectionFields": {
       "AppliesTo": [
@@ -2847,6 +2855,36 @@
         "TypecastSegmentSupported": "Edm.Boolean"
       }
     },
+    "Capabilities.ExpandByKeyRestrictionsBase": {
+      "$kind": "ComplexType",
+      "BaseType": "Capabilities.ExpandRestrictionsBase",
+      "Properties": {
+        "Expandable": "Edm.Boolean",
+        "MaxLevels": "Edm.Int32",
+        "StreamsExpandable": "Edm.Boolean"
+      }
+    },
+    "Capabilities.ExpandByKeyRestrictionsType": {
+      "$kind": "ComplexType",
+      "BaseType": "Capabilities.ExpandByKeyRestrictionsBase",
+      "Properties": {
+        "Expandable": "Edm.Boolean",
+        "MaxLevels": "Edm.Int32",
+        "NonExpandableProperties": "Collection(Edm.NavigationPropertyPath)",
+        "NonExpandableStreamProperties": "Collection(Edm.PropertyPath)",
+        "StreamsExpandable": "Edm.Boolean"
+      }
+    },
+    "Capabilities.ExpandCollectionRestrictionsType": {
+      "$kind": "ComplexType",
+      "BaseType": "Capabilities.ExpandRestrictionsBase",
+      "Properties": {
+        "ExpandByKeyRestrictions": "Capabilities.ExpandByKeyRestrictionsBase",
+        "Expandable": "Edm.Boolean",
+        "MaxLevels": "Edm.Int32",
+        "StreamsExpandable": "Edm.Boolean"
+      }
+    },
     "Capabilities.ExpandRestrictionsBase": {
       "$kind": "ComplexType",
       "Properties": {
@@ -2857,8 +2895,9 @@
     },
     "Capabilities.ExpandRestrictionsType": {
       "$kind": "ComplexType",
-      "BaseType": "Capabilities.ExpandRestrictionsBase",
+      "BaseType": "Capabilities.ExpandCollectionRestrictionsType",
       "Properties": {
+        "ExpandByKeyRestrictions": "Capabilities.ExpandByKeyRestrictionsBase",
         "Expandable": "Edm.Boolean",
         "MaxLevels": "Edm.Int32",
         "NonExpandableProperties": "Collection(Edm.NavigationPropertyPath)",
@@ -4463,7 +4502,28 @@
         "CriticalityRepresentation": "UI.CriticalityRepresentationType",
         "IconUrl": "Edm.String",
         "Label": "Edm.String",
-        "Value": "Edm.Untyped"
+        "Value": {
+          "DerivedTypeConstraint": [
+            "Edm.PrimitiveType",
+            "Collection(Edm.Binary)",
+            "Collection(Edm.Boolean)",
+            "Collection(Edm.Byte)",
+            "Collection(Edm.Date)",
+            "Collection(Edm.DateTimeOffset)",
+            "Collection(Edm.Decimal)",
+            "Collection(Edm.Double)",
+            "Collection(Edm.Duration)",
+            "Collection(Edm.Guid)",
+            "Collection(Edm.Int16)",
+            "Collection(Edm.Int32)",
+            "Collection(Edm.Int64)",
+            "Collection(Edm.SByte)",
+            "Collection(Edm.Single)",
+            "Collection(Edm.String)",
+            "Collection(Edm.TimeOfDay)"
+          ],
+          "Type": "Edm.Untyped"
+        }
       }
     },
     "UI.DataFieldAbstract": {

package/lib/json/from-csn.js

@@ -117,7 +117,7 @@
 
 const { dictAdd } = require('../compiler/dictionaries');
 const { quotedLiteralPatterns } = require('../compiler/builtins');
-const { isAnnotationExpression } = require('../base/builtins');
+const { exprProperties } = require('../base/builtins');
 const { CompilerAssertion } = require('../base/error');
 const { Location } = require('../base/location');
 const { XsnSource } = require('../compiler/xsn-model');
@@ -141,11 +141,6 @@ const typeProperties = [
   'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull', 'default',
   'keys', 'on',                 // only with 'target'
 ];
-const exprProperties = [
-  // do not include CSN v0.1.0 properties here:
-  'ref', 'xpr', 'list', 'val', '#', 'func', 'SELECT', 'SET', // Core Compiler checks SELECT/SET
-  'param', 'literal', 'args', 'cast', // only with 'ref'/'ref'/'val'/'func'
-];
 
 // Groups of properties which cannot be used together:
 const xorGroups = {
@@ -619,16 +614,16 @@ const schema = compileSchema( {
     optional: exprProperties,
   },
   where: {
-    class: 'condition',
+    class: 'condition', inKind: [ 'extend' ],
   },
   groupBy: {
-    arrayOf: expr, optional: exprProperties,
+    arrayOf: expr, optional: exprProperties, inKind: [ 'extend' ],
   },
   having: {
-    class: 'condition',
+    class: 'condition', inKind: [ 'extend' ],
   },
   orderBy: {
-    arrayOf: expr, optional: [ 'sort', 'nulls', ...exprProperties ],
+    arrayOf: expr, optional: [ 'sort', 'nulls', ...exprProperties ], inKind: [ 'extend' ],
   },
   sort: {
     type: stringVal,
@@ -637,7 +632,7 @@ const schema = compileSchema( {
     type: stringVal,            // TODO: test for valid ones?
   },
   limit: {
-    type: object, requires: 'rows', optional: [ 'rows', 'offset' ],
+    type: object, requires: 'rows', optional: [ 'rows', 'offset' ], inKind: [ 'extend' ],
   },
   rows: {
     class: 'expression',
@@ -1467,7 +1462,7 @@ function annoValue( val, spec ) {
       ++virtualLine;
       return r;
     }
-    else if (isAnnotationExpression( val )) {
+    else if (exprProperties.some( prop => val[prop] !== undefined )) {
       const s = schema['@'].schema['-expr'];
       const r = { location: location() };
       Object.assign( r, object( val, s ) );

package/lib/json/to-csn.js

@@ -234,11 +234,11 @@ function compactModel( model, options = model.options || {} ) {
   }
   // 'namespace' for complete model is 'namespace' of first source
   // (not a really useful property at all, avoids XSN inspection by Umbrella)
-  for (const first in srcDict) {
+  const first = Object.keys( srcDict )[0];
+  if (first) {
     const { namespace } = srcDict[first];
     if (namespace?.name?.path)
       csn.namespace = pathName( namespace.name.path );
-    break;
   }
   set( 'definitions', csn, model );
   if (Object.keys(model.vocabularies || {}).length > 0)
@@ -249,15 +249,16 @@ function compactModel( model, options = model.options || {} ) {
   set( 'i18n', csn, model );
   set( 'sources', csn, model );
   // Set $location, use $extra properties of first source as resulting $extra properties
-  for (const first in srcDict) {
-    const loc = srcDict[first].location;
+  const firstSourceName = Object.keys( srcDict )[0];
+  if (firstSourceName) {
+    const firstSource = srcDict[firstSourceName];
+    const loc = firstSource.location;
     if (loc && loc.file) {
       Object.defineProperty( csn, '$location', {
         value: { file: loc.file }, configurable: true, writable: true, enumerable: withLocations,
       } );
     }
-    set( '$extra', csn, srcDict[first] );
-    break;
+    set( '$extra', csn, firstSource );
   }
 
   const srcNames = Object.keys( srcDict );
@@ -273,7 +274,8 @@ function compactModel( model, options = model.options || {} ) {
   const compilerCsnFlavor = flavorMap[options.csnFlavor] ||
                             (options.parseCdl ? 'parsed' : 'inferred');
   if (!options.testMode) {
-    csn.meta = Object.assign( {}, model.meta, meta, { creator, compilerCsnFlavor } );
+    csn.meta = Object.assign( {}, model.meta, meta,
+                              { creator, compilerVersion, compilerCsnFlavor } );
     csn.$version = csnVersion;
   }
   else if (meta !== undefined) {
@@ -322,16 +324,11 @@ function usings( srcDict ) {
 function extensions( node, csn, model ) {
   if (model.kind && model.kind !== 'source')
     return undefined;
-  const exts = node.map( definition );
-  if (gensrcFlavor) {
-    for (const name of Object.getOwnPropertyNames( model.definitions || {} ).sort()) {
-      const art = model.definitions[name];
-      // From definitions (without redefinitions) with potential inferred elements:
-      const result = { annotate: Object.create(null) };
-      attachAnnotations( result, 'annotate', { [name]: art }, art.$inferred );
-      if (result.annotate[name])
-        exts.push( { annotate: name, ...result.annotate[name] } );
-    }
+  let exts = node.map( definition );
+  if (gensrcFlavor && model.definitions) {
+    const gensrc = { annotate: Object.create( null ), extend: Object.create( null ) };
+    attachAnnotations( gensrc, null, model.definitions, null );
+    exts = exts.concat( Object.values( gensrc.annotate ), Object.values( gensrc.extend ) );
   }
   return exts.sort(             // TODO: really sort with parse.cdl?
     (a, b) => (a.annotate || a.extend).localeCompare( b.annotate || b.extend )
@@ -378,36 +375,64 @@ function sources( srcDict, csn, model ) {
   }
 }
 
-function attachAnnotations( annotate, prop, dict, inferred, insideReturns = false ) {
-  const annoDict = Object.create( dictionaryPrototype );
+// create annotate and extend statements for CSN flavor gensrc
+// TODO: rename this function - also refactor
+function attachAnnotations( annotate, prop, dict, inferred, withExtend, insideReturns = false ) {
+  const annoDict = prop && Object.create( dictionaryPrototype );
   const names = Object.keys( dict );
   if (strictMode)
     names.sort();
   for (const name of names) {
     const entry = dict[name];
     const inf = inferred || entry.$inferred; // is probably always inferred if parent was
-    const sub = (inf) ? annotationsAndDocComment( entry ) : {};
-    if (entry.$expand === 'annotate') {
+    const withExt = withExtend || entry.$expand === 'extend';
+    const extProp = (entry.$expand === 'extend') ? 'extend' : 'annotate';
+    if (withExt && !entry.$inferred && entry.kind === 'enum') {
+      // currently just added enum - test for safety
+      if (dict[$inferred])
+        annoDict[name] = definition( entry );
+      continue;
+    }
+    let sub = {};
+    if (inf)
+      annotationsAndDocComment( entry, sub );
+
+    if (entry.$expand === 'annotate' || entry.$expand === 'extend') {
       if (entry.actions)
         attachAnnotations( sub, 'actions', entry.actions, inf );
       else if (entry.params)
         attachAnnotations( sub, 'params', entry.params, inf );
+
+      if (entry.$expand === 'extend' && (sub.actions || sub.params)) {
+        // there is only `annotate` with actions/params
+        annotate.annotate[name] = { annotate: name, ...sub };
+        sub = {};
+      }
+
       const obj = entry.returns || entry;
-      const many = obj.items || obj;
+      const many = obj.items || obj; // TODO: many many?
       const elems = (many.targetAspect || many).elements;
-      if (elems)
-        attachAnnotations( sub, 'elements', elems, inf, entry.returns );
-      else if (many.enum)       // make 'enum' annotations appear in 'elements' annotate
-        attachAnnotations( sub, 'elements', many.enum, inf, entry.returns );
-      else if (entry.foreignKeys) // make 'foreignKeys' annotations appear in 'elements' annotate
-        attachAnnotations( sub, 'elements', entry.foreignKeys, inf );
+      if (elems) {
+        attachAnnotations( sub, 'elements', elems, inf, withExt, entry.returns );
+      }
+      else if (many.enum) { // make 'enum' annotations appear in 'elements' annotate
+        attachAnnotations( sub, (withExt ? 'enum' : 'elements'),
+                           many.enum, inf, withExt, entry.returns );
+      }
+      else if (entry.foreignKeys) { // make 'foreignKeys' annotations appear in 'elements' annotate
+        attachAnnotations( sub, 'elements', entry.foreignKeys, inf, withExt );
+      }
+    }
+    if (Object.keys( sub ).length > 0) {
+      if (prop)
+        annoDict[name] = (withExt) ? { kind: 'extend', ...sub } : sub;
+      else
+        annotate[extProp][name] = { [extProp]: name, ...sub };
     }
-    if (Object.keys( sub ).length)
-      annoDict[name] = sub;
   }
-  if (Object.keys( annoDict ).length) {
+  if (prop && Object.keys( annoDict ).length) {
     if (insideReturns)
-      annotate.returns = { elements: annoDict };
+      annotate.returns = { [prop]: annoDict };
     else
       annotate[prop] = annoDict;
   }
@@ -524,7 +549,7 @@ function enumerableQueryElements( select ) {
   return (universalCsn && select !== select._main._leadingQuery);
 }
 
-// Should we render the elements?  (and items?)
+// Should we render the elements?  (and enum, items?)
 function keepElements( node, line ) {
   if (universalCsn)
     // $expand = null/undefined: not elements not via expansion
@@ -562,8 +587,7 @@ function keepElements( node, line ) {
  *
  * @param {object} node
  */
-function annotationsAndDocComment( node ) {
-  const csn = {};
+function annotationsAndDocComment( node, csn = {} ) {
   const transformer = transformers['@'];
   const keys = Object.keys( node ).filter( a => a.charAt(0) === '@' ).sort();
   for (const prop of keys) {

package/lib/parsers/AstBuildingParser.js

@@ -8,6 +8,7 @@ const { functionsWithoutParentheses } = require('./identifiers');
 
 const { pathName } = require('../compiler/utils');
 const { quotedLiteralPatterns, specialFunctions } = require('../compiler/builtins');
+const { primaryExprProperties } = require('../base/builtins');
 
 const { parseMultiLineStringLiteral } = require('../language/multiLineStringParser');
 const { normalizeNewLine, normalizeNumberString } = require('../language/textUtils');
@@ -100,11 +101,6 @@ const extensionsCode = {
 const PRECEDENCE_OF_EQUAL = 10;
 
 class AstBuildingParser extends BaseParser {
-  leanConditions = {
-    afterBrace: true,
-    fail: true,
-  };
-
   constructor( lexer, keywords, table, options, messageFunctions ) {
     super( lexer, keywords, table ); // lexer has file
     this.options = options;
@@ -201,7 +197,7 @@ class AstBuildingParser extends BaseParser {
   queryOnLeftSloppyAlias( _arg, mode ) {
     if (mode === 'M' || this.isNoKeywordInRuleFollow( _arg, mode ))
       return true;
-    // TODO TOOL: have a base parser method for the test
+    // TODO TOOL: have a base parser method for the test - or extra mode (recovery)
     if (this.conditionTokenIdx === this.tokenIdx &&        // tested on same
         this.conditionStackLength == null)                 // after error recovery
       return false;
@@ -238,7 +234,7 @@ class AstBuildingParser extends BaseParser {
   }
 
   prepareSpecialFunction() {
-    const func = this.tokens[this.tokenIdx - 2].keyword?.toUpperCase();
+    const func = this.lb(2).keyword?.toUpperCase();
     // TODO: use lower-case in specialFunctions
     const spec = specialFunctions[func];
     this.dynamic_.call = { func, argPos: 0 };
@@ -261,7 +257,7 @@ class AstBuildingParser extends BaseParser {
       if (generic !== 'expr')
         return (generic === 'intro') ? 'GenericIntro' : type;
       // if both intro and expr: specialFunctions[fn][argPos][token] = 'expr'
-      const next = this.tokens[this.tokenIdx + 1];
+      const next = this.lb(-1);
       if (next && next.type !== ',' && next.type !== ')' &&
           this.dynamic_.generic[next.keyword?.toUpperCase?.()] !== 'separator')
         return 'GenericIntro';
@@ -309,8 +305,7 @@ class AstBuildingParser extends BaseParser {
       this.dynamic_.inSelectItem ??= [];
       this.dynamic_.inSelectItem = [ ...this.dynamic_.inSelectItem ];
     }
-    this.dynamic_.inSelectItem.push(arg ||
-      (this.tokens[this.tokenIdx - 2].type === '.' ? 'inline' : 'expand'));
+    this.dynamic_.inSelectItem.push(arg || (this.lb(2).type === '.' ? 'inline' : 'expand'));
   }
 
   /**
@@ -321,7 +316,7 @@ class AstBuildingParser extends BaseParser {
   modifierRestriction() {
     const top = this.dynamic_.inSelectItem?.at(-1);
     const insideExpand = this.dynamic_.inSelectItem?.includes('expand');
-    const next = this.tokens[this.tokenIdx]?.keyword;
+    const next = this.la()?.keyword;
     return insideExpand || (next !== 'key' && top === 'inline');
   }
   modifierRestrictionError( args, offending ) {
@@ -340,7 +335,7 @@ class AstBuildingParser extends BaseParser {
       return false;
     // TODO: it would be best to set this.dynamic_.inSelectItem to null in filters
     // (as <prepare>)
-    const next = this.tokens[this.tokenIdx + 1]?.type;
+    const next = this.lb(-1)?.type;
     return next === '*' || next === '{';
   }
 
@@ -357,7 +352,7 @@ class AstBuildingParser extends BaseParser {
   // <prec=10, postfix=once> + test that the next token is not `null`; TODO: code
   // completion for `… default 3 not ~;` → currently just `null` but hey
   isNegatedRelation( prec ) {
-    return this.tokens[this.tokenIdx + 1]?.keyword === 'null' ||
+    return this.lb(-1)?.keyword === 'null' ||
       this.precNone_( prec );
   }
 
@@ -372,7 +367,7 @@ class AstBuildingParser extends BaseParser {
   }
 
   isNamedArg() {
-    const type = this.tokens[this.tokenIdx + 1]?.type;
+    const type = this.lb(-1)?.type;
     return type !== ':' && type !== '=>';
   }
 
@@ -522,13 +517,13 @@ class AstBuildingParser extends BaseParser {
   }
 
   noRepeatedCardinality( _arg, mode ) {
-    if (this.tokens[this.tokenIdx - 2]?.type !== ']')
+    if (this.lb(2)?.type !== ']')
       return false;
     if (mode === 'M')
       return true;
     // currently just warning if same cardinality provided twice
     const same = { one: '1', many: '*' }[this.la().keyword];
-    return this.tokens[this.tokenIdx - 3]?.text !== same;
+    return this.lb(3)?.text !== same;
   }
   noRepeatedCardinalityError( args ) {
     let openIdx = this.tokenIdx - 2;
@@ -606,7 +601,7 @@ class AstBuildingParser extends BaseParser {
       const { arrayAnno } = this.dynamic_;
       if (!arrayAnno[0])
         return arrayAnno[0] == null ? 'duplicate' : arg;
-      arrayAnno[0] = this.tokens[this.tokenIdx + 1]?.keyword;
+      arrayAnno[0] = this.lb(-1)?.keyword;
     }
     else if (arg === 'bracket') { // syntax-invalid-ellipsis
       // closing bracket not allowed if last `...` in array is with `up to
@@ -628,7 +623,7 @@ class AstBuildingParser extends BaseParser {
   }
 
   beforeColon() {
-    return this.tokens[this.tokenIdx + 1]?.text !== ':';
+    return this.lb(-1)?.text !== ':';
   }
 
   fail( _arg, mode ) {
@@ -652,13 +647,13 @@ class AstBuildingParser extends BaseParser {
       return;
     // assumes no value < -1:
     const location = (tokenAhead > 0)
-      ? this.combineLocation( this.la(), this.tokens[this.tokenIdx + tokenAhead] )
-      : this.tokens[this.tokenIdx + tokenAhead].location;
+      ? this.combineLocation( this.la(), this.lb(-tokenAhead) )
+      : this.lb(-tokenAhead).location;
     this.error( msgId, location, textArgs );
   }
 
   warnIfColonFollows( name ) {
-    if (this.l() === ':') {
+    if (this.la().type === ':') {
       this.warning( 'syntax-missing-parens', name,
                     { code: '@‹anno›', op: ':', newcode: '@(‹anno›…)' },
                     // eslint-disable-next-line @stylistic/max-len
@@ -680,7 +675,7 @@ class AstBuildingParser extends BaseParser {
 
   reportDubiousAnnoSpacing() {
     const at = this.lb();
-    const before = this.tokens[this.tokenIdx - 2];
+    const before = this.lb(2);
     if (before?.type === 'Id' && before.location.endLine === at.location.line &&
         before.location.endCol === at.location.col) {
       this.warning( 'syntax-expecting-anno-space', at.location, { code: '@' },
@@ -888,7 +883,7 @@ class AstBuildingParser extends BaseParser {
   classifyImplicitName( category, ref ) {
     if (!ref || ref.path) {     // TODO: func
       const tokenIndex = ref?.path.at(-1)?.location.tokenIndex;
-      const token = this.prevTokenWithIndex( tokenIndex ) ?? this.tokens[this.tokenIdx - 1];
+      const token = this.prevTokenWithIndex( tokenIndex ) ?? this.lb();
       const { parsedAs } = token;
       if (parsedAs && parsedAs !== 'token' && parsedAs !== 'keyword')
         token.parsedAs = category;
@@ -1097,7 +1092,7 @@ class AstBuildingParser extends BaseParser {
 
   // TODO: can we remove `;`/EOF from the expected-set for `annotate Foo with ⎀`?
   checkWith( keyword ) {
-    if (this.lb() !== keyword || ![ ';', '}', 'EOF' ].includes( this.l() ))
+    if (this.lb() !== keyword || ![ ';', '}', 'EOF' ].includes( this.la().type ))
       return;
     const tok = this.la();
     const docTokenIndex = this.docCommentIndex &&
@@ -1152,15 +1147,15 @@ class AstBuildingParser extends BaseParser {
   }
 
   // see also <guard=nestedExpand>
-  reportExpandInline( column, isInline ) {
-    // called before matching `{`
+  reportExpandInline( column, sqlStyle, isInline ) {
+    // called before matching `{` (or `*` with inline)
     if (column.value && !column.value.path) {
       // improve error location when using "inline" `.{…}` after ref (arguments and
       // filters not covered, not worth the effort); after an expression where
       // the last token is an identifier, not the `.` is wrong, but the `{`:
-      const token = (isInline && this.tokens[this.tokenIdx - 2].type !== 'Id')
-        ? this.lb()
-        : this.la();
+      const token = (isInline && this.lb(2)?.type !== 'Id')
+        ? this.lb()             // e.g. with `func() .{` → the `.` is wrong
+        : this.la();            // after `current_date` → the `{` is wrong
       this.error( 'syntax-unexpected-nested-proj', token,
                   { code: isInline ? '.{ ‹inline› }' : '{ ‹expand› }' },
                   'Unexpected $(CODE); nested projections can only be used after a reference' );
@@ -1169,6 +1164,15 @@ class AstBuildingParser extends BaseParser {
       // - no errors for refs inside expand/inline, but for refs in sibling expr
       // - think about: reference to these (sub) elements from other view
     }
+    else if (sqlStyle && this.la().text === '{') {
+      this.message( 'syntax-invalid-nested-proj', this.la(),
+                    {
+                      code: isInline ? '.{ ‹inline› }' : '{ ‹expand› }',
+                      keyword: 'select from … { … }',
+                    },
+                    // eslint-disable-next-line @stylistic/max-len
+                    'Unexpected $(CODE); nested projections can only be used within a CDL-style $(KEYWORD)' );
+    }
   }
 
   reportDuplicateClause( prop, erroneous, chosen, code ) {
@@ -1198,6 +1202,15 @@ class AstBuildingParser extends BaseParser {
     }
   }
 
+  checkStructProps( dict ) {
+    const special = primaryExprProperties.find( prop => dict[prop] !== undefined );
+    if (special || dict['=']) {
+      const prop = special || '=';
+      this.message( 'syntax-invalid-anno-struct', dict[prop].name.location,
+                    { '#': (special ? 'std' : 'ref'), prop } );
+    }
+  }
+
   // TODO: remove the check from the parser; move it to shared.js
   checkTypeArgs( art ) {
     const args = art.$typeArgs;
@@ -1212,7 +1225,7 @@ class AstBuildingParser extends BaseParser {
   locationOfPrevTokens( offset ) {
     // TODO: use combined location of lb() and la() and move actions accordingly
     // (for error recovery)
-    const { file, line, col } = this.tokens[this.tokenIdx - offset].location;
+    const { file, line, col } = this.lb( offset ).location;
     const { endLine, endCol } = this.lb().location;
     return {
       file,