@sap/cds-compiler 4.4.4 → 4.6.0

package/lib/json/from-csn.js

@@ -376,7 +376,7 @@ const schema = compileSchema( {
     type: object,
     optional: [ 'src', 'min', 'max' ],
     inKind: [ 'element', 'type', 'mixin' ],
-    onlyWith: [ 'target', 'targetAspect', 'id' ], // also in 'ref[]'
+    onlyWith: [ 'target', 'targetAspect', 'where' ], // also in 'ref[]'
   },
   items: {
     type: object,
@@ -1325,14 +1325,13 @@ function stringValOrNull( val, spec ) {
 
 function scalenum( val, spec ) {
   if ([ 'floating', 'variable' ].includes(val))
-    return { val, literal: 'string', location: location() };
+    return { val, literal: 'string', location: location() }; // XSN TODO: remove `literal`
   return natnum(val, spec );
 }
 
 function natnum( val, spec ) {
   if (typeof val === 'number' && val >= 0 && Number.isSafeInteger( val ))
-    //  XSN TODO: do not require literal
-    return { val, literal: 'number', location: location() };
+    return { val, location: location() };
   const loc = location(true);
   error( 'syntax-expecting-unsigned-int', loc,
          { '#': spec.msgVariant || 'csn', prop: spec.msgProp, op: '*' } );
@@ -1342,7 +1341,7 @@ function natnum( val, spec ) {
 // Use with spec.msgVariant !
 function natnumOrStar( val, spec ) {
   return (val === '*')
-    ? { val, literal: 'string', location: location() }
+    ? { val, location: location() }
     : natnum( val, spec );
 }
 

package/lib/json/to-csn.js

@@ -14,7 +14,7 @@
 const { locationString } = require('../base/messages');
 const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
 const { pathName } = require('../compiler/utils');
-const { CompilerAssertion } = require('../base/error');
+const { CompilerAssertion, ModelError } = require('../base/error');
 
 const compilerVersion = require('../../package.json').version;
 const creator = `CDS Compiler v${ compilerVersion }`;
@@ -93,6 +93,7 @@ const transformers = {
   cardinality,                 // also in pathItem: after 'id', before 'where'
   targetAspect,
   target,
+  $filtered: value,            // assoc+filter
   foreignKeys,
   enum: enumDict,
   items,
@@ -205,6 +206,10 @@ const typeProperties = [
   'foreignKeys', 'on',      // for explicit ON/keys with REDIRECTED
   '$typeArgs', // for unresolved type arguments, e.g. through parseCql
 ];
+// Properties which cause a `cast` property to be rendered
+const castProperties = [
+  'target', 'enum', 'items', 'type',
+];
 
 const csnDictionaries = [
   'args', 'params', 'enum', 'mixin', 'elements', 'actions', 'definitions',
@@ -305,8 +310,14 @@ function csnDictionary( csn, sort, cloneOptions = false ) {
     ? proto
     : (proto) ? Object.prototype : null;
   const r = Object.create( dictProto );
-  for (const n of (sort) ? Object.keys(csn).sort() : Object.keys(csn))
-    r[n] = sortCsn( csn[n], cloneOptions );
+  for (const n of (sort) ? Object.keys(csn).sort() : Object.keys(csn)) {
+    // CSN does not allow any dictionary that are not objects.
+    // The compiler handles it, but a pre-transformed OData CSN won't trigger recompilation.
+    if (csn[n] && typeof csn[n] === 'object')
+      r[n] = sortCsn(csn[n], cloneOptions);
+    else
+      throw new ModelError(`Found non-object dictionary entry: "${ n }" of type "${ typeof csn[n] }"`);
+  }
 
   return r;
 }
@@ -1176,6 +1187,18 @@ function args( node ) {
 }
 
 function anno( node ) {
+  if (!node)
+    return true;                // `@aBool` short for `@aBool: true`
+  if (universalCsn && node.$inferred) {
+    // TODO: return undefined for all values of node.$inferred (except 'NULL')?
+    if (node.$inferred === 'prop' || node.$inferred === '$generated' || // via propagator.js
+        node.$inferred === 'parent-origin')
+      return undefined;
+    else if (node.$inferred === 'NULL')
+      return null;
+  }
+  if (node.$inferred && gensrcFlavor)
+    return undefined;
   if (node.$tokenTexts) // expressions in annotation values
     return Object.assign({ '=': node.$tokenTexts }, expression( node ));
   return value(node);
@@ -1476,7 +1499,9 @@ function addElementAsColumn( elem, cols ) {
     // elements of sub queries (in expr) are hidden (not set via Object.assign):
     if (!expr.cast && expr.elements)
       setHidden( col, 'elements', expr.elements );
-    if (elem.type && !elem.type.$inferred || elem.target && !elem.target.$inferred)
+    // CDL-style cast with explicit type properties
+    if (castProperties.findIndex(prop => (elem[prop] &&
+        !elem[prop].$inferred && !elem[prop][$inferred])) > -1)
       cast( col, elem );
   }
   finally {

package/lib/language/antlrParser.js

@@ -78,9 +78,11 @@ class RewriteTypeTokenStream extends antlr4.CommonTokenStream {
 function initTokenRewrite( recognizer, ts ) { // ts = tokenStream
   ts.DOTbeforeBRACE = Parser.DOTbeforeBRACE;
   ts.BRACE = tokenTypeOf( recognizer, "'{'" );
+  ts.BRACE_CLOSE = tokenTypeOf( recognizer, "'}'" );
   ts.DOT = tokenTypeOf( recognizer, "'.'" );
   ts.ASTERISK = tokenTypeOf( recognizer, "'*'" );
   ts.AT = tokenTypeOf( recognizer, "'@'" );
+  ts.SEMICOLON = tokenTypeOf( recognizer, "';'" );
   ts.NEW = Parser.NEW;
   ts.Identifier = Parser.Identifier;
   ts.PAREN = tokenTypeOf( recognizer, "'('" );
@@ -90,7 +92,22 @@ function initTokenRewrite( recognizer, ts ) { // ts = tokenStream
     if (ts.DOT && ts.DOTbeforeBRACE)
       recognizer.tokenRewrite[ts.DOTbeforeBRACE - Parser.Identifier] = ts.DOT;
   }
-  // console.log( ts.DOTbeforeBRACE, ts.BRACE, ts.DOT, recognizer.tokenRewrite );
+}
+
+function initCodeCompletionTokenArrays( parser ) {
+  // Set of top-level keywords used for code completion after token '}'
+  // belonging to a top-level definition
+  const startRuleIndex = parser.ruleNames.indexOf('start');
+  const startState = parser.atn.ruleToStartState[startRuleIndex].stateNumber;
+  const tokens = parser.atn.nextTokens(parser.atn.states[startState]);
+  tokens.removeOne(parser.symbolicNames.indexOf('NAMESPACE'));
+  tokens.removeOne(parser.symbolicNames.indexOf('HideAlternatives'));
+
+  parser.topLevelKeywords = [];
+  for (const interval of tokens.intervals) {
+    for (let i = interval.start; i < interval.stop; i++)
+      parser.topLevelKeywords.push(i);
+  }
 }
 
 function tokenTypeOf( recognizer, literalName ) {
@@ -123,6 +140,7 @@ function parse( source, filename = '<undefined>.cds',
   parser.$messageFunctions = messageFunctions;
 
   initTokenRewrite( parser, tokenStream );
+  initCodeCompletionTokenArrays(parser);
   // comment the following 2 lines if you want to output the parser errors directly:
   parser.messageErrorListener = errorListener;
   parser._errHandler = new errorStrategy.KeywordErrorStrategy();

package/lib/language/errorStrategy.js

@@ -447,16 +447,33 @@ function intervalSetToArray( recognizer, expected, excludesForNextToken ) {
     for (let j = v.start; j < v.stop; j++) {
       // a generic keyword as such does not appear in messages, only its replacements,
       // which are function name and argument position dependent:
-      if (j === pc.GenericExpr)
+      if (j === pc.GenericExpr) {
         names.push( ...recognizer.$genericKeywords.expr );
-      else if (j === pc.GenericSeparator)
+      }
+      else if (j === pc.GenericSeparator) {
         names.push( ...recognizer.$genericKeywords.separator );
-      else if (j === pc.GenericIntro)
+      }
+      else if (j === pc.GenericIntro) {
         names.push( ...recognizer.$genericKeywords.introMsg );
+      }
+      else if (j === pc.SemicolonTopLevel) {
+        // We only insert a semikolon (i.e. make it optional) after a closing brace.
+        // If the previous token is not `}`, don't propose these keywords, as ';' is required.
+        if (recognizer._input.LA(-1) === recognizer._input.BRACE_CLOSE) {
+          const name = recognizer.topLevelKeywords.map(i => expected
+            .elementName(recognizer.literalNames, recognizer.symbolicNames, i));
+          names.push(...name);
+          if (recognizer._ctx.outer?.kind !== 'source') {
+            if (names.includes('<EOF>'))
+              names.splice(names.indexOf('<EOF>'), 1);
+          }
+        }
+      }
       // other expected tokens usually appear in messages, except the helper tokens
       // which are used to solve ambiguities via the parser method setLocalToken():
-      else if (j !== pc.HelperToken1 && j !== pc.HelperToken2)
+      else if (j !== pc.HelperToken1 && j !== pc.HelperToken2) {
         names.push( expected.elementName(recognizer.literalNames, recognizer.symbolicNames, j ) );
+      }
     }
   }
   // The parser method excludeExpected() additionally removes some tokens from the message:
@@ -524,10 +541,14 @@ function getTokenDisplay( token, recognizer ) {
   if (!token)
     return '<EOF>';
   const t = token.type;
-  if (t === antlr4.Token.EOF || t === antlr4.Token.EPSILON )
+  if (t === antlr4.Token.EOF || t === antlr4.Token.EPSILON ) {
     return '<EOF>';
-  else if (token.text === '.')  // also for DOTbeforeBRACE
-    return "'.'";
+  }
+  else if (t === recognizer.constructor.DOTbeforeBRACE) {
+    if (recognizer.getTokenStream().LT(2).text === '{')
+      return "'.{'";
+    return "'.*'";
+  }
   return recognizer.literalNames[t] || recognizer.symbolicNames[t];
 }
 

package/lib/language/genericAntlrParser.js

@@ -8,6 +8,7 @@
 
 const antlr4 = require('antlr4');
 const { ATNState } = require('antlr4/src/antlr4/atn/ATNState');
+const { DEFAULT: CommonTokenFactory } = require('antlr4/src/antlr4/CommonTokenFactory');
 const { dictAdd, dictAddArray } = require('../base/dictionaries');
 const locUtils = require('../base/location');
 const { parseDocComment } = require('./docCommentParser');
@@ -23,7 +24,7 @@ const {
 } = require('../compiler/classes');
 const { isBetaEnabled } = require('../base/model');
 const { weakLocation } = require('../base/location');
-const { normalizeNewLine } = require('./textUtils');
+const { normalizeNewLine, normalizeNumberString } = require('./textUtils');
 
 const $location = Symbol.for('cds.$location');
 
@@ -107,6 +108,8 @@ Object.assign(GenericAntlrParser.prototype, {
   fixNewKeywordPlacement,
   signedExpression,
   numberLiteral,
+  unsignedIntegerLiteral,
+  assignAnnotationValue,
   quotedLiteral,
   pathName,
   docComment,
@@ -117,13 +120,14 @@ Object.assign(GenericAntlrParser.prototype, {
   createDict,
   createArray,
   finalizeDictOrArray,
-  createPrefixOp,
+  insertSemicolon,
   setMaxCardinality,
   setNullability,
   reportDuplicateClause,
   reportUnexpectedExtension,
   reportUnexpectedSpace,
   pushIdent,
+  pushItem,
   handleComposition,
   associationInSelectItem,
   reportExpandInline,
@@ -911,10 +915,6 @@ function expressionAsAnnotationValue( assignment, cond ) {
     return;
   Object.assign(assignment, cond.cond);
   assignment.$tokenTexts = this.tokensToStringRepresentation(cond);
-  if (!this.isBetaEnabled(this.options, 'annotationExpressions')) {
-    this.error( 'syntax-unsupported-expression', [ cond.cond.location ], {},
-                'Expressions in annotation values are not supported' );
-  }
 }
 
 // If a '-' is directly before an unsigned number, consider it part of the number;
@@ -941,12 +941,27 @@ function signedExpression( args, expr ) {
   }
 }
 
-// Return AST for number token `token` with optional token `sign`.  Represent
-// the number as number in property `val` if the number can safely be
-// represented as an integer.  Otherwise, represent the number by a string, the
-// token lexeme.
-function numberLiteral( token, sign, text = token.text ) {
+/**
+ * Return number literal (XSN) for number token `token` with optional token `sign`.
+ * Represent the number as a JS number in property `val` if the number can safely be
+ * represented as one.  Represent the number by a string, the token lexeme, if the
+ * stringified version of the number does not match the token lexeme.
+ *
+ * TODO: Always use text !== `${ num }`
+ */
+function numberLiteral( sign, text = this._input.LT(-1).text ) {
+  const token = this._input.LT(-1);
   let location = this.tokenLocation( token );
+  const nextToken = this._input.LT(1);
+  if (token.type === this.constructor.Number &&
+      token.stop + 1 === nextToken.start &&
+      (nextToken.type === this.constructor.Identifier ||
+       nextToken.type < this.constructor.Identifier && /^[a-z]+$/i.test( nextToken.text ))) {
+    // TODO: Make it an error in v5
+    this.warning('syntax-expecting-space', nextToken, {},
+                 'Expecting a space between a number and a keyword/identifier');
+  }
+
   if (sign) {
     const { endLine, endCol } = location;
     location = this.startLocation( sign );
@@ -957,17 +972,65 @@ function numberLiteral( token, sign, text = token.text ) {
   }
 
   const num = Number.parseFloat( text || '0' ); // not Number.parseInt() !
+  const normalized = normalizeNumberString(text);
+  if (normalized !== `${ num }` && normalized !== `${ sign.text }${ num }`)
+    return { literal: 'number', val: normalized, location };
+  return { literal: 'number', val: num, location };
+}
+
+/**
+ * Given `token`, return a number literal (XSN).  If the number is not an unsigned integer
+ * or it can't be represented in JS, emit an error.
+ */
+function unsignedIntegerLiteral() {
+  const token = this._input.LT(-1);
+  const location = this.tokenLocation( token );
+  const text = token.text || '0';
+  const num = Number.parseFloat( text ); // not Number.parseInt() !
   if (!Number.isSafeInteger(num)) {
-    if (sign == null) {
-      this.error( 'syntax-expecting-unsigned-int', token,
-                  { '#': !text.match(/^\d*$/) ? 'normal' : 'unsafe' } );
-    }
+    this.error( 'syntax-expecting-unsigned-int', token,
+                { '#': !text.match(/^\d*$/) ? 'normal' : 'unsafe' } );
+  }
+  else if (text.match(/^\d+[.]\d+$/)) {
+    // More restrictive check: 10.0 emits a message, because we don't expect
+    // any decimal places.
+    const dotLoc = { ...location };
+    dotLoc.col += text.indexOf('.');
+    dotLoc.endCol = dotLoc.col + 1;
+    this.info( 'syntax-ignoring-decimal', dotLoc );
+  }
+  return { literal: 'number', val: num, location };
+}
 
-    else if (text !== `${ num }`) {
-      return { literal: 'number', val: text, location };
+// Make the annotation `anno` have `value` as value.  This function is basically
+// just `Object.assign`, but we really try to represent the provided CDL number as
+// JSON number.  We give a warning if this is not possible or leads to a precision
+// loss.
+function assignAnnotationValue( anno, value ) {
+  const { val } = value;
+  if (value.literal === 'number' && typeof val !== 'number') {
+    // a number in CDL, but stored as string in `val` - due to rounding or scientific notation
+    let num = Number.parseFloat( val || '0' );
+    const inf = !Number.isFinite( num );
+    if (inf)
+      num = val;
+    if (inf || relevantDigits( val ) !== relevantDigits( num.toString() )) {
+      this.warning( 'syntax-invalid-anno-number', value.location,
+                    { '#': (inf ? 'infinite' : 'rounded' ), rawvalue: val, value: num },
+                    {
+                      std: 'Annotation number $(RAWVALUE) is put as $(VALUE) into the CSN',
+                      rounded: 'Annotation number $(RAWVALUE) is rounded to $(VALUE)',
+                      // eslint-disable-next-line max-len
+                      infinite: 'Annotation value $(RAWVALUE) is infinite as number and put as string into the CSN',
+                    } );
     }
+    value.val = num;
   }
-  return { literal: 'number', val: num, location };
+  Object.assign( anno, value );
+}
+
+function relevantDigits( val ) {
+  return val.replace( /0*(e.+)?$/i, '' ).replace( /\./, '' ).replace( /^[-+0]+/, '' );
 }
 
 // Create AST node for quoted literals like string and e.g. date'2017-02-22'.
@@ -1036,6 +1099,16 @@ function pushIdent( path, ident, prefix ) {
   }
 }
 
+function pushItem( array, val ) {
+  if (!array)
+    return;
+
+  if (val != null)
+    array.push(val);
+  else
+    array.broken = true;
+}
+
 // For :param, #variant, #symbol, @(…) and @Begin and `@` inside annotation paths
 function reportUnexpectedSpace( prefix = this._input.LT(-1),
                                 location = this.tokenLocation( this._input.LT(1) ) ) {
@@ -1173,14 +1246,35 @@ function finalizeDictOrArray( dict ) {
   loc.endCol = stop.stop - stop.start + stop.column + 2;
 }
 
-function createSource() {
-  return new XsnSource();
+function insertSemicolon() {
+  const currentToken = this._input.tokens[this._input.index];
+  const requireSemicolon = this.topLevelKeywords.includes(currentToken.type);
+
+  if (requireSemicolon) {
+    this.noAssignmentInSameLine();
+    const prev = this._input.LT(-1);
+    const t = CommonTokenFactory.create(
+      currentToken.source,
+      this.literalNames.indexOf( "';'" ),
+      '', antlr4.Token.DEFAULT_CHANNEL,
+      prev.stop, prev.stop,
+      prev.line, prev.column
+    );
+
+    t.tokenIndex = prev.tokenIndex + 1;
+
+    this._input.tokens.splice(t.tokenIndex, 0, t);
+
+    // Update tokenIndex: There could have been comments between two non-hidden tokens.
+    for (let tokenIndex = t.tokenIndex + 1; tokenIndex < this._input.tokens.length; tokenIndex++)
+      this._input.tokens[tokenIndex].tokenIndex += 1;
+
+    this._input.index = t.tokenIndex;
+  }
 }
 
-// Create AST node for prefix operator `op` and arguments `args`
-function createPrefixOp( token, args ) {
-  const op = this.valueWithTokenLocation( token.text.toLowerCase(), token );
-  return { op, args, location: this.combinedLocation( op, args[args.length - 1] ) };
+function createSource() {
+  return new XsnSource();
 }
 
 // Create AST node for binary operator `op` and arguments `args`

package/lib/language/textUtils.js

@@ -49,9 +49,25 @@ function normalizeNewLine( str ) {
   return str.replace(new RegExp(cdlNewLineRegEx, 'ug'), '\n');
 }
 
+/**
+ * Normalizes the given number (as a string):
+ *
+ *  - removes leading zeroes (`0`) to avoid accidental octal-conversion
+ *
+ * @param {string} str
+ * @return {string}
+ */
+function normalizeNumberString( str ) {
+  const num = str.replace(/^([+-]?)0+(\d)/, '$1$2');
+  if (!num.includes('.'))
+    return num;
+  return num.replace(/([.]\d)0+$/, '$1');
+}
+
 module.exports = {
   isWhitespaceOrNewLineOnly,
   isWhitespaceCharacterNoNewline,
   cdlNewLineRegEx,
   normalizeNewLine,
+  normalizeNumberString,
 };

package/lib/main.d.ts

@@ -27,9 +27,9 @@ declare namespace compiler {
     messages?: object[]
     /**
      * Dictionary of message-ids and their reclassified severity.  This option
-     * can be used to increase the severity of messages.  The compiler will
-     * ignore decreased severities as this may lead to issues during
-     * compilation otherwise.
+     * can be used to increase the severity of messages.  The compiler may
+     * ignore decreased severities of error messages as this may lead to issues
+     * during compilation otherwise.
      */
     severities?: { [messageId: string]: MessageSeverity}
     /**
@@ -1023,6 +1023,31 @@ declare namespace compiler {
       function migration(csn: CSN, options: SqlOptions, beforeImage: CSN): SqlMigrationResult;
     }
 
+    /**
+     * Renders the given CSN into EDM in the JSON format _and_ XML format.
+     * That is, it is a combination of `to.edm()` and `to.edmx()`.
+     * Requires `options.service` to be set.
+     *
+     * Not to be confused with `for.odata()`, which returns an OData transformed CSN.
+     *
+     * @returns An object `'<protocol>': object` where the value is `'<serviceName>': object` entry
+     *          which consists of `{edmx: string, edm?: object}`.
+     * @since v4.6.0
+     */
+    function odata(csn: CSN, options?: ODataOptions): Record<string, object>;
+    namespace odata {
+      /**
+       * Renders the given CSN into EDM in JSON format _and_ XML format for each service.
+       * That is, it is a combination of `to.edm.all()` and `to.edmx.all()`.
+       * If `options.serviceNames` is not set, all services will be rendered.
+       *
+       * @returns A map of `'<protocol>': object` where each entry is `'<serviceName>': object` entries where
+       *          each entry consists of `{edmx: string, edm?: object}`.
+       * @since v4.6.0
+       */
+      function all(csn: CSN, options: ODataOptions): Record<string, object>;
+    }
+
     /**
      * Renders the given CSN into EDM (JSON format).  Requires `options.service` to be set.
      *

package/lib/main.js

@@ -158,6 +158,9 @@ module.exports = {
     edmx: Object.assign((...args) => snapi.edmx(...args), {
       all: (...args) => snapi.edmx.all(...args)
     }),
+    odata: Object.assign((...args) => snapi.odata2(...args), {
+      all: (...args) => snapi.odata2.all(...args)
+    }),
   },
   // Convenience for hdbtabledata calculation in @sap/cds
   getArtifactCdsPersistenceName: (...args) => csnUtils.getArtifactDatabaseNameOf(...args),

package/lib/model/csnRefs.js

@@ -613,7 +613,7 @@ function csnRefs( csn, universalReady ) {
           return resolvePath( path, alias._select || alias._ref, null,
                               'alias', ncache.$queryNumber );
         }
-        const mixin = ncache._select.mixin && ncache._select.mixin[head];
+        const mixin = ncache._select.mixin?.[head];
         if (mixin && {}.hasOwnProperty.call( ncache._select.mixin, head )) {
           setCache( mixin, '_parent', qcache._select );
           return resolvePath( path, mixin, null, 'mixin', ncache.$queryNumber );
@@ -818,6 +818,9 @@ function csnRefs( csn, universalReady ) {
       as = `$_column_${ colIndex + 1 }`;
     setCache( col, '$as', as );
     let type = parentElementOrQueryCache;
+    if (col.cast)
+      traverseType( col.cast, col, 'column', colIndex, initNode );
+
     while (type.items)
       type = type.items;
     const elem = setCache( col, '_element', type.elements[as] );

package/lib/model/csnUtils.js

@@ -1,8 +1,8 @@
 'use strict';
 
-const { csnRefs, implicitAs } = require('../model/csnRefs');
+const { csnRefs, implicitAs, pathId } = require('./csnRefs');
 const { applyTransformations, applyTransformationsOnNonDictionary, applyTransformationsOnDictionary } = require('../transform/db/applyTransformations');
-const { isBuiltinType } = require('../compiler/builtins.js');
+const { isBuiltinType, isMagicVariable, isAnnotationExpression } = require('../compiler/builtins.js');
 const {
   sortCsn,
   cloneCsnDictionary: _cloneCsnDictionary,
@@ -1088,18 +1088,21 @@ function getLastPartOfRef( ref ) {
  * @param {object} toNode
  * @param {boolean} [overwrite]
  * @param {object} excludes
+ * @param {array} annoNames (copy only these annotations or all if undefined)
+ * @returns {array} copiedAnnoNames
  */
-function copyAnnotations( fromNode, toNode, overwrite = false, excludes = {} ) {
+function copyAnnotations( fromNode, toNode, overwrite = false, excludes = {}, annoNames = undefined ) {
   // Ignore if no toNode (in case of errors)
   if (!toNode)
     return;
 
-  const annotations = Object.keys(fromNode).filter(key => key.startsWith('@'));
+  if (annoNames == null)
+    annoNames = Object.keys(fromNode).filter(key => key.startsWith('@'));
 
-  for (const anno of annotations) {
+  annoNames.forEach((anno) => {
     if ((toNode[anno] === undefined || overwrite) && !excludes[anno])
-      toNode[anno] = fromNode[anno];
-  }
+      toNode[anno] = cloneAnnotationValue(fromNode[anno]);
+  });
 }
 
 
@@ -1118,13 +1121,9 @@ function copyAnnotationsAndDoc( fromNode, toNode, overwrite = false ) {
   if (!toNode)
     return;
 
-  const annotations = Object.keys(fromNode)
-    .filter(key => key.startsWith('@') || key === 'doc');
-
-  for (const anno of annotations) {
-    if (toNode[anno] === undefined || overwrite)
-      toNode[anno] = fromNode[anno];
-  }
+  copyAnnotations(fromNode, toNode, overwrite);
+  if (toNode.doc === undefined || overwrite)
+    toNode.doc = fromNode.doc;
 }
 
 /**
@@ -1449,6 +1448,10 @@ function isAssociationOperand( arg, path, inspectRef ) {
   return art && art.target !== undefined;
 }
 
+function pathName( ref ) {
+  return ref ? ref.map( pathId ).join( '.' ) : '';
+}
+
 module.exports = {
   getUtils,
   cloneCsn: cloneCsnNonDict, // Umbrella relies on this name
@@ -1456,6 +1459,8 @@ module.exports = {
   cloneCsnDictionary,
   cloneAnnotationValue,
   isBuiltinType,
+  isMagicVariable,
+  isAnnotationExpression,
   applyAnnotationsFromExtensions,
   forEachGeneric,
   forEachDefinition,
@@ -1496,4 +1501,5 @@ module.exports = {
   cardinality2str,
   isAssociationOperand,
   isDollarSelfOrProjectionOperand,
+  pathName,
 };

package/lib/model/revealInternalProperties.js

@@ -321,8 +321,11 @@ function artifactIdentifier( node, parent ) {
     Object.defineProperty( node, '__unique_id__', { value: uniqueId-- } );
   const outerNum = node.$effectiveSeqNo || node.__unique_id__;
   let outer = outerNum != null ? `##${ outerNum }` : '';
-  if (node._outer) {            // anon aspect in targetAspect | items
-    outer = (node._outer.targetAspect === node) ? `/target${ outer }` : `/items${ outer }`;
+  if (node._outer) { // anon aspect in targetAspect | items | $calcDepElement
+    outer = (node.kind === '$annotation')
+    // eslint-disable-next-line prefer-template
+      ? `/${ quoted( '@' + node.name.id ) }`
+      : `/${ node.kind || 'items' }${ outer }`;
     node = node._outer;
   }
   if (node === parent)