@sap/cds-compiler 3.7.2 → 3.8.0

package/lib/compiler/finalize-parse-cdl.js

@@ -29,17 +29,18 @@ function finalizeParseCdl( model ) {
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked,
     initMembers,
-    extensionsDict,
   } = model.$functions;
 
   resolveTypesAndExtensionsForParseCdl();
   return;
 
   function resolveTypesAndExtensionsForParseCdl() {
+    const late = model.$lateExtensions;
     const extensions = [];
 
-    for (const name in extensionsDict) {
-      for (const ext of extensionsDict[name]) {
+    // TODO: why not just use the extensions as they are from the first source?
+    for (const name in late) {
+      for (const ext of late[name]._extensions) {
         ext.name.absolute = resolveUncheckedPath( ext.name, 'extend', ext );
         // Initialize members and define annotations in sub-elements.
         initMembers( ext, ext, ext._block, true );

package/lib/compiler/index.js

@@ -15,7 +15,7 @@
 'use strict';
 
 const { resolveModule, resolveModuleSync } = require('../utils/moduleResolve');
-const parseLanguage = require('../language/antlrParser');
+const parseLanguage = require('../language/antlrParser'); // TODO: should we do some lazyload here?
 const parseCsn = require('../json/from-csn');
 
 const assertConsistency = require('./assert-consistency');

package/lib/compiler/kick-start.js

@@ -31,9 +31,9 @@ function kickStart( model ) {
    */
   function setAncestorsAndService( name ) {
     const art = model.definitions[name];
-    if (!('_parent' in art))
+    if (art._parent === undefined)
       return;                   // nothing to do for builtins and redefinitions
-    if (art.query && !('_ancestors' in art))
+    if (art.query && art._ancestors === undefined)
       setProjectionAncestors( art );
 
     let parent = art._parent;

package/lib/compiler/populate.js

@@ -26,7 +26,6 @@ const {
 const {
   dictAdd, dictAddArray, dictFirst, dictForEach,
 } = require('../base/dictionaries');
-const { dictLocation } = require('../base/location');
 const { weakLocation } = require('../base/messages');
 const { CompilerAssertion } = require('../base/error');
 
@@ -48,6 +47,7 @@ const {
 } = require('./utils');
 
 const $inferred = Symbol.for('cds.$inferred');
+const $location = Symbol.for('cds.$location');
 
 
 // Export function of this file.
@@ -61,6 +61,8 @@ function populate( model ) {
     resolvePath,
     attachAndEmitValidNames,
     initArtifact,
+    chooseAnnotationsInArtifact,
+    extendArtifactAfter,
   } = model.$functions;
   model.$volatileFunctions.environment = environment;
   Object.assign( model.$functions, {
@@ -191,13 +193,13 @@ function populate( model ) {
     if (!art)
       return art;
     // if (--depth) throw Error(`ET: ${ Object.keys(art) }`)
-    if ('_effectiveType' in art)
+    if (art._effectiveType !== undefined)
       return art._effectiveType;
 
     // console.log(message( null, art.location, art, {}, 'Info','FT').toString())
     const chain = [];
     // console.log( 'ET-START:', art.kind, art.name )
-    while (art && !('_effectiveType' in art)) {
+    while (art && art._effectiveType === undefined) {
       setLink( art, '_effectiveType', 0 ); // initial setting in case of cycles
       chain.push( art );
       art = getOrigin( art );
@@ -210,13 +212,15 @@ function populate( model ) {
 
     chain.reverse();
     for (const a of chain) {
-      // console.log( 'ET-DO:', a.name, art?.kind )
       // Without type, value.path or _origin at beginning, link to itself:
+      chooseAnnotationsInArtifact( a );
       art = populateArtifact( a, art ) || a;
       if (a.elements$ || a.enum$)
         mergeSpecifiedElementsOrEnum( a );
       setLink( a, '_effectiveType', art );
       a.$effectiveSeqNo = ++effectiveSeqNo;
+      // console.log( 'ET-DO:', effectiveSeqNo, a?.kind, a?.name, a._extensions?.elements?.length )
+      extendArtifactAfter( a ); // after setting _effectiveType (for messages)
     }
     // console.log( 'ET-END:', art?.kind, art?.name )
     return art;
@@ -226,6 +230,8 @@ function populate( model ) {
     // Name-resolution relevant properties directly at artifact:
     // ‹view›.elements of input must have been moved (to elements$) before!
     // console.log('Q:',art.elements,art.enum,art.items,!!art.query)
+    if (art.includes)           // first version of includes via effectiveTpe()
+      art.includes.forEach( i => effectiveType( i._artifact ) );
     if (art.elements != null || art.enum != null || art.items != null)
       return art;
     if (art.target) {
@@ -294,7 +300,7 @@ function populate( model ) {
     if (!art)
       return undefined;         // TODO: null?
     // if (--depth) throw Error(`GOR: ${ Object.keys(art) }`)
-    if ('_origin' in art)
+    if (art._origin !== undefined)
       return art._origin;
     if (art.type)               // not stored in _origin
       return resolveType( art.type, art );
@@ -328,7 +334,7 @@ function populate( model ) {
   }
 
   function resolveType( ref, user ) {
-    if ('_artifact' in ref)
+    if (ref._artifact !== undefined)
       return ref._artifact;
     while (user._outer)         // in items
       user = user._outer;
@@ -631,8 +637,10 @@ function populate( model ) {
     if (!effectiveType( assoc )?.target)
       return initFromColumns( elem, elem.expand );
     const { targetMax } = path[path.length - 1].cardinality || getCardinality( assoc );
-    if (targetMax && (targetMax.val === '*' || targetMax.val > 1))
-      elem.items = { location: dictLocation( elem.expand ) }; // TODO: array location
+    if (targetMax && (targetMax.val === '*' || targetMax.val > 1)) {
+      elem.items = { location: elem.expand[$location] };
+      setLink( elem.items, '_outer', elem );
+    }
     return initFromColumns( elem, elem.expand );
   }
 
@@ -1286,7 +1294,7 @@ function populate( model ) {
     setLink( art, '_service', service );
     setLink( art, '_block', model.$internal );
     initArtifact( art, !!autoexposed );
-    effectiveType( art );    // TODO: necessary? see traverseElementEnvironments()
+    effectiveType( art );
     // TODO: try to set locations of elements locations of orig target elements
     newAutoExposed.push( art );
     return art;

package/lib/compiler/propagator.js

@@ -99,6 +99,13 @@ function propagate( model ) {
       for (const target of targets) {
         const origin = getOrigin( target );
         if (origin) {
+          // Calculated elements that are simple references: `calc = field;`.
+          // Respect sibling properties in inheritance.
+          if (target._calcOrigin?._origin && target.value?._artifact) {
+            chain.push({ target, source: target.value._artifact });
+            if (checkAndSetStatus( target.value._artifact ))
+              news.push(target.value._artifact);
+          }
           chain.push( { target, source: origin } );
           if (checkAndSetStatus( origin ))
             news.push( origin );
@@ -178,13 +185,13 @@ function propagate( model ) {
     }
     else {
       target[prop] = Object.assign( {}, val, { $inferred: 'prop' } );
-      if ('_artifact' in val)
+      if (val._artifact !== undefined)
         setLink( target[prop], '_artifact', val._artifact );
-      if ('_outer' in val)
+      if (val._outer !== undefined)
         setLink( target[prop], '_outer', val._outer );
-      if ('_parent' in val)
+      if (val._parent !== undefined)
         setLink( target[prop], '_parent', val._parent );
-      if ('_main' in val)
+      if (val._main !== undefined)
         setLink( target[prop], '_main', val._main );
     }
   }
@@ -359,7 +366,7 @@ function checkAndSetStatus( art ) {
 }
 
 function setEffectiveType( target, source ) {
-  if ('_effectiveType' in source)
+  if (source._effectiveType !== undefined)
     setLink( target, '_effectiveType', source._effectiveType);
 }
 

package/lib/compiler/resolve.js

@@ -46,21 +46,18 @@ const {
 } = require('../base/model');
 const { dictAdd } = require('../base/dictionaries');
 const { dictLocation } = require('../base/location');
-const { searchName, weakLocation } = require('../base/messages');
+const { weakLocation } = require('../base/messages');
 const { combinedLocation } = require('../base/location');
 const { typeParameters } = require('./builtins');
 
-const { kindProperties } = require('./base');
 const {
   pushLink,
   setLink,
   setArtifactLink,
   setMemberParent,
   withAssociation,
-  storeExtension,
   dependsOn,
   dependsOnSilent,
-  setExpandStatusAnnotate,
   testExpr,
   targetMaxNotOne,
   traverseQueryPost,
@@ -84,16 +81,9 @@ function resolve( model ) {
   } = model.$messageFunctions;
   const {
     resolvePath,
-    checkAnnotate,
-    initAnnotations,
-    copyAnnotationsForExtensions,
-    attachAndEmitValidNames,
     lateExtensions,
-    applyTypeExtensions,
     effectiveType,
     getOrigin,
-    chooseAnnotationsInArtifact,
-    extensionFor,
     resolveType,
     resolveTypeArgumentsUnchecked,
   } = model.$functions;
@@ -126,14 +116,9 @@ function resolve( model ) {
     // Phase 4: resolve all artifacts:
     forEachDefinition( model, resolveRefs );
     forEachGeneric( model, 'vocabularies', resolveRefs );
-    // for builtin types
-    forEachGeneric( model.definitions.cds, '_subArtifacts', chooseAnnotationsInArtifact);
-    forEachGeneric( model.definitions['cds.hana'], '_subArtifacts', chooseAnnotationsInArtifact);
-    // Phase 6: apply ANNOTATE on auto-exposed entities and unknown artifacts:
-    lateExtensions( annotateMembers );
-    if (model.extensions)
-      model.extensions.map( annotateUnknown );
-    // Phase 7: report cyclic dependencies:
+    // create “super” ANNOTATE statements for annotations on unknown artifacts:
+    lateExtensions();
+    // report cyclic dependencies:
     detectCycles( model.definitions, ( user, art, location ) => {
       if (location) {
         error( 'ref-cyclic', [ location, user ], { art }, {
@@ -461,9 +446,6 @@ function resolve( model ) {
         checkStructureCast(art);
     }
 
-    annotateMembers( art );     // TODO recheck - recursively, but also forEachMember below
-    chooseAnnotationsInArtifact( art );
-
     forEachMember( art, resolveRefs, art.targetAspect );
 
     // Set '@Core.Computed' in the Core Compiler to have it propagated...
@@ -497,7 +479,15 @@ function resolve( model ) {
       parent = parent._parent;
 
     if (!allowedInKind.includes(art._main.kind)) {
-      error( 'def-invalid-calc-elem', loc, { '#': art._main.kind } );
+      if (art.$inferred === 'include') {
+        // even for include-chains, we find the correct ref due to element-expansion.
+        const include = art._main.includes.find(i => i._artifact === art._origin._main);
+        error('ref-invalid-calc-elem', [ include.location || art.value.location, art ],
+              { '#': art._main.kind });
+      }
+      else {
+        error( 'def-invalid-calc-elem', loc, { '#': art._main.kind } );
+      }
     }
     else if (!allowedInKind.includes(parent.kind)) {
       error( 'def-invalid-calc-elem', loc, { '#': parent.kind } );
@@ -560,149 +550,6 @@ function resolve( model ) {
     }
   }
 
-  // Phase 4 - annotations ---------------------------------------------------
-  // Some functions remain here for the moment, as resolve functionality is called
-  // from annotate functions, which should not be the case (TODO!)
-
-  function annotateUnknown( ext ) {
-    // extensions may have annotations for elements/actions/... which may
-    // themselves may be unknown
-    forEachMember(ext, annotateUnknown);
-
-    if (ext.$extension) // extension for known artifact -> already applied
-      return;
-    annotateMembers( ext );
-    chooseAnnotationsInArtifact( ext );
-  }
-
-  /**
-   * @param {XSN.Artifact} art
-   * @param {XSN.Extension[]} [extensions]
-   * @param {string} [prop]
-   * @param {string} [name]
-   * @param {object} [parent]
-   * @param {string} [kind]
-   */
-  function annotateMembers( art, extensions, prop, name, parent, kind ) {
-    const showMsg = !art && parent && parent.kind !== 'annotate';
-    if (!art && extensions && extensions.length) {
-      if (Array.isArray( parent ))
-        return;
-      const parentExt = extensionFor(parent);
-      art = parentExt[prop] && parentExt[prop][name];
-      if (!art) {
-        art = {
-          kind,                 // for setMemberParent()
-          name: { id: name, location: extensions[0].name.location },
-          location: extensions[0].location,
-        };
-        setMemberParent( art, name, parentExt, prop );
-        art.kind = 'annotate';  // after setMemberParent()!
-      }
-    }
-
-    for (const ext of extensions || []) {
-      if ('_artifact' in ext.name) // already applied
-        continue;
-      setArtifactLink( ext.name, art );
-
-      if (art) {
-        checkAnnotate( ext, art );
-        initAnnotations( ext, ext._block, ext.kind ); // TODO: do in define.js
-        copyAnnotationsForExtensions( ext, art );
-        // eslint-disable-next-line no-shadow
-        forEachMember( ext, ( elem, name, prop ) => {
-          storeExtension( elem, name, prop, art, ext._block );
-        });
-      }
-      if (showMsg) {
-        // somehow similar to checkDefinitions():
-        const feature = kindProperties[parent.kind][prop];
-        if (prop === 'elements' || prop === 'enum') {
-          if (!feature) {
-            warning( 'anno-unexpected-elements', [ ext.name.location, art ], {},
-                     'Elements only exist in entities, types or typed constructs' );
-          }
-          else {
-            const isEntity = (parent.returns?.type || parent.type)?._artifact?.kind === 'entity';
-            let variant = parent.enum ? 'enum' : 'element';
-            if (isEntity)
-              variant = 'entity-element';
-            else if (parent.returns)
-              variant = 'returns';
-            notFound( 'anno-undefined-element', ext.name.location, art,
-                      { '#': variant, art: parent, name },
-                      parent.elements || parent.enum );
-          }
-        }
-        else if (prop === 'actions') {
-          if (!feature) {
-            warning( 'anno-unexpected-actions', [ ext.name.location, art._parent || art ], {},
-                     'Actions and functions only exist top-level and for entities' );
-          }
-          else {
-            notFound( 'anno-undefined-action', ext.name.location, art,
-                      { art: searchName( parent, name, 'action' ) },
-                      parent.actions );
-          }
-        }
-        else if (!feature) {
-          warning( 'anno-unexpected-params', [ ext.name.location, art ], {},
-                   'Parameters only exist for actions or functions' );
-        } // TODO: entities betaMod
-        else {
-          notFound( 'anno-undefined-param', ext.name.location, art,
-                    { art: searchName( parent, name, 'param' ) },
-                    parent.params );
-        }
-      }
-    }
-    if (art?._annotate) {
-      const aor = art.returns || art;
-      const obj = aor.items || aor.targetAspect || aor;
-      // Currently(?), effectiveType() does not calculate the effective type of
-      // its line item:
-      if (art._annotate.elements) // explicit $expand on aor needed
-        setExpandStatusAnnotate( aor, 'annotate' );
-      annotate( obj, 'element', 'elements', 'enum', art );
-      annotate( art, 'action', 'actions' );
-      annotate( art, 'param', 'params' );
-      // const { returns } = art._annotate;
-      // if (returns) {
-      //   const dict = returns.elements;
-      //   const env = obj.returns && obj.returns.elements || null;
-      //   for (const n in dict)
-      //     annotateMembers( env && env[n], dict[n], 'elements', n, parent, 'element' );
-      // }
-    }
-
-    if (art?._extendType) {
-      // Only works because annotateMembers is called in resolveRefs() _after_ `.type` was resolved.
-      // TODO: If we allow extending included elements, we may need custom $expand,
-      //       similar to annotate above.
-      art._extendType.forEach(resolveRefs);
-      applyTypeExtensions(art);
-    }
-
-    return;
-
-    function notFound( msgId, location, address, args, validDict ) {
-      // TODO: probably move this to shared.js and use for EXTEND, too
-      const msg = message( msgId, [ location, address ], args );
-      attachAndEmitValidNames(msg, validDict);
-    }
-
-    // eslint-disable-next-line no-shadow
-    function annotate( obj, kind, prop, altProp, parent = obj ) {
-      const dict = art._annotate[prop];
-      if (dict && art._annotate[prop])
-        setExpandStatusAnnotate( art, 'annotate' );
-      const env = obj[prop] || altProp && obj[altProp] || null;
-      for (const n in dict)
-        annotateMembers( env && env[n], dict[n], prop, n, parent, kind );
-    }
-  }
-
   // Phase 4 - queries and associations --------------------------------------
 
   function resolveQuery( query ) {
@@ -1069,6 +916,7 @@ function resolve( model ) {
     // TODO(#8942): May not be necessary if effectiveType() is adapted.  Furthermore, the enum
     //              trick may be removed if effectiveType() does not stop at enums.
     // TODO: this is wrong - we must check typeArt.enum, not its effectiveType
+    // TODO: this function is not complete(!): parallel `elements` and `length`, … - rework function
     const cyclic = new Set();
     let effectiveTypeArt = effectiveType( typeArt );
     while (effectiveTypeArt && effectiveTypeArt.enum && !cyclic.has(effectiveTypeArt)) {
@@ -1177,7 +1025,7 @@ function resolve( model ) {
   }
 
   function resolveParamsAndWhere( step, expected, user, extDict, isLast ) {
-    const alias = step._navigation && step._navigation.kind === '$tableAlias' && step._navigation;
+    const alias = (step._navigation?.kind === '$tableAlias') ? step._navigation : null;
     const type = alias || effectiveType( step._artifact );
     const art = (type && type.target) ? type.target._artifact : type;
     if (!art)
@@ -1190,14 +1038,19 @@ function resolve( model ) {
       if (step.where)
         resolveExpr( step.where, 'filter', user, environment( type ) );
     }
-    else if (step.where && step.where.location || step.cardinality ) {
+    else if (step.where?.location || step.cardinality ) {
       const location = combinedLocation( step.where, step.cardinality );
+      let variant = alias ? 'tableAlias' : 'std';
+      if (expected === 'from')
+        variant = 'from';
       // XSN TODO: filter$location including […]
-      message( 'expr-no-filter', [ location, user ], { '#': expected },
-               {
-                 std: 'A filter can only be provided when navigating along associations',
-                 from: 'A filter can only be provided for the source entity or associations',
-               } );
+      message( 'expr-no-filter', [ location, user ], { '#': variant }, {
+        std: 'A filter can only be provided when navigating along associations',
+        // to help users for `… from E:toF { toF[…].x }`
+        // eslint-disable-next-line max-len
+        tableAlias: 'A filter can only be provided when navigating along associations, but found table alias',
+        from: 'A filter can only be provided for the source entity or associations',
+      } );
     }
   }
 

package/lib/compiler/shared.js

@@ -182,7 +182,6 @@ function fns( model ) {
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked,
     resolvePath,
-    checkAnnotate,
     attachAndEmitValidNames,
   } );
   return;
@@ -301,7 +300,7 @@ function fns( model ) {
   function resolvePath( ref, expected, user, extDict, msgArt ) {
     if (ref == null)       // no references -> nothing to do
       return undefined;
-    if ('_artifact' in ref)     // also true for _artifact: undefined
+    if (ref._artifact !== undefined)
       return ref._artifact;
     if (!ref.path || ref.path.broken || !ref.path.length) {
       // incomplete type AST or empty env (already reported)
@@ -598,7 +597,7 @@ function fns( model ) {
     // if (head.id === 'k') {console.log(Object.keys(user));
     // throw new CompilerAssertion(JSON.stringify(user.name))}
     // if head._artifact is set or is null then it was already computed once
-    if ('_artifact' in head)
+    if (head._artifact !== undefined)
       return Array.isArray(head._artifact) ? false : head._artifact;
     // console.log(pathName(path), !spec.next && !extDict &&
     //   (spec.useDefinitions || env.$frontend === 'json' || env))
@@ -616,7 +615,7 @@ function fns( model ) {
         break;                    // TODO: probably remove _$next link
       const e = art.artifacts || art.$tableAliases || Object.create(null);
       const r = e[head.id];
-      if (r) {
+      if (r && r.$inferred !== '$internal') {
         if (Array.isArray(r)) { // redefinitions
           setArtifactLink( head, r );
           return false;
@@ -650,11 +649,14 @@ function fns( model ) {
         if (r[0].kind === '$navElement' && r.every( e => !e._parent.$duplicates )) {
           // only complain about ambiguous source elements if we do not have
           // duplicate table aliases, only mention non-ambiguous source elems
-          const names = r.filter( e => !e.$duplicates )
-            .map( e => `${ e.name.alias }.${ e.name.element }` );
-          if (names.length) {
-            error( 'ref-ambiguous', [ head.location, user ], { id: head.id, names },
-                   'Ambiguous $(ID), replace by $(NAMES)' );
+          const uniqueNames = r.filter( e => !e.$duplicates);
+          if (uniqueNames.length) {
+            const names = uniqueNames.filter( e => e._parent.$inferred !== '$internal' )
+              .map( e => `${ e.name.alias }.${ e.name.element }` );
+            let variant = names.length === uniqueNames.length ? 'std' : 'few';
+            if (names.length === 0)
+              variant = 'none';
+            error( 'ref-ambiguous', [ head.location, user ], { '#': variant, id: head.id, names });
           }
         }
         setArtifactLink( head, r );
@@ -935,7 +937,7 @@ function fns( model ) {
     msg.validNames = Object.create( null );
     for (const name of Object.keys( valid )) {
       // ignore internal types such as cds.Association
-      if (valid[name].internal || valid[name].deprecated)
+      if (valid[name].internal || valid[name].deprecated || valid[name].$inferred === '$internal')
         continue;
       msg.validNames[name] = valid[name];
     }
@@ -949,49 +951,6 @@ function fns( model ) {
             { std: `Valid: ${ names.sort().join(', ') }`, zero: 'No valid names' });
     }
   }
-
-  // Issue messages for annotations on namespaces and builtins
-  // (TODO: really here?, probably split main artifacts vs returns)
-  // see also lateExtensions() where similar messages are reported
-  function checkAnnotate( construct, art ) {
-    // TODO: Handle extend statements properly: Different message for empty extend?
-
-    // Namespaces cannot be annotated in CSN but because they exist as XSN artifacts
-    // they can still be applied. Namespace annotations are extracted in to-csn.js
-    // In parseCdl mode USINGs and other unknown references are generated as
-    // namespaces which would lead to false positives.
-    // TODO: should this really be different to annotate-unknown?
-    if (art.kind === 'namespace') {
-      info( 'anno-namespace', [ construct.name.location, construct ], {},
-            'Namespaces can\'t be annotated' );
-    }
-    // Builtin annotations would also get lost. Same as for namespaces:
-    // extracted in to-csn.js
-    else if (art.builtin === true) {
-      info( 'anno-builtin', [ construct.name.location, construct ], {},
-            'Builtin types should not be annotated. Use custom type instead' );
-    }
-    // --> without art._block, art not found
-    else if (construct.kind === 'annotate' && art._block?.$frontend === 'cdl') {
-      if (construct.$syntax === 'returns' && art.kind !== 'action' && art.kind !== 'function' ) {
-        // `annotate ABC with returns {}` is handled just like `elements`. Warn if it is used
-        // for non-actions.  We can't only check for !art.returns, because `action A();` is valid.
-        // `art._block` ensures that `art` is a defined def.
-        warning('ext-unexpected-returns', [ construct.name.location, construct ],
-                { keyword: 'returns', meta: art.kind }, 'Unexpected $(KEYWORD) for $(META)');
-      }
-      else if (construct.$syntax !== 'returns' &&
-          (art.kind === 'action' || art.kind === 'function') && construct.elements) {
-        warning('ext-expected-returns', [ construct.name.location, construct ], {
-          '#': art.kind, keyword: 'returns', code: 'annotate ‹name› with returns { … }',
-        }, {
-          std: 'Expected $(CODE)', // unused variant
-          action: 'Expected $(KEYWORD) when annotating action return structure, i.e. $(CODE)',
-          function: 'Expected $(KEYWORD) when annotating function return structure, i.e. $(CODE)',
-        });
-      }
-    }
-  }
 }
 
 module.exports = {

package/lib/compiler/tweak-assocs.js

@@ -256,7 +256,7 @@ function tweakAssocs( model ) {
       const fk = linkToOrigin( orig, name, elem, 'foreignKeys', elem.location );
       fk.$inferred = 'rewrite'; // Override existing value; TODO: other $inferred value?
       // TODO: re-check for case that foreign key is managed association
-      if ('_effectiveType' in orig)
+      if (orig._effectiveType !== undefined)
         setLink( fk, '_effectiveType', orig._effectiveType);
       const te = copyExpr( orig.targetElement, elem.location );
       if (elem._redirected) {

package/lib/compiler/utils.js

@@ -55,7 +55,7 @@ function annotationLocation( anno ) {
  * @param {*} [val]
  * @param {string} [literal]
  */
-function annotateWith( art, anno, location = art.location, val = true, literal = 'boolean' ) {
+function setAnnotation( art, anno, location = art.location, val = true, literal = 'boolean' ) {
   if (art[anno])  // do not overwrite user-defined including null
     return;
   art[anno] = {
@@ -448,7 +448,7 @@ module.exports = {
   annotationIsFalse,
   annotationHasEllipsis,
   annotationLocation,
-  annotateWith,
+  setAnnotation,
   setLink,
   setArtifactLink,
   linkToOrigin,