@sap/cds-compiler 2.15.2 → 3.0.2

package/lib/base/optionProcessorHelper.js

@@ -153,36 +153,67 @@ function createOptionProcessor() {
    * Internal: Define a general or command option.
    * Throws if the option is already registered in the given command context.
    * or in the given command.
+   *
    * @private
    * @see option()
    */
   function _addOption(cmd, optString, validValues, options) {
-    const opt = _parseOptionString(optString, validValues);
-    Object.assign(opt, options);
+    const cliOpt = _parseOptionString(optString, validValues);
+    Object.assign(cliOpt, options);
+    _addLongOption(cmd, cliOpt.longName, cliOpt);
+    _addShortOption(cmd, cliOpt.shortName, cliOpt);
+
+    for (const alias of cliOpt.aliases || []) {
+      const aliasOpt = Object.assign({ }, cliOpt, { isAlias: true });
+      _addLongOption(cmd, alias, aliasOpt); // use same camelName, etc. for alias
+    }
+
+    return cmd;
+  }
 
-    if (cmd.options[opt.longName]) {
-      throw new Error(`Duplicate assignment for long option ${opt.longName}`);
-    } else if (optionProcessor.options[opt.longName]) {
+  /**
+   * Internal: Add longName to the list of options.
+   * Throws if the option is already registered in the given command context.
+   * or in the given command.
+   * `longName` may differ from `opt.longName`, e.g. for aliases.
+   *
+   * @private
+   * @see _addOption()
+   */
+  function _addLongOption(cmd, longName, opt) {
+    if (cmd.options[longName]) {
+      throw new Error(`Duplicate assignment for long option ${longName}`);
+    } else if (optionProcessor.options[longName]) {
       // This path is only taken if optString is for commands
       optionProcessor.optionClashes.push({
-        option: opt.longName,
-        description: `Command '${cmd.longName}' has option clash with general options for: ${opt.longName}`
+        option: longName,
+        description: `Command '${cmd.longName}' has option clash with general options for: ${longName}`
       });
     }
-    cmd.options[opt.longName] = opt;
-    if (opt.shortName) {
-      if (cmd.options[opt.shortName]) {
-        throw new Error(`Duplicate assignment for short option ${opt.shortName}`);
-      } else if (optionProcessor.options[opt.shortName]) {
-        // This path is only taken if optString is for commands
-        optionProcessor.optionClashes.push({
-          option: opt.shortName,
-          description: `Command '${cmd.longName}' has option clash with general options for: ${opt.shortName}`
-        });
-      }
-      cmd.options[opt.shortName] = opt;
+    cmd.options[longName] = opt;
+  }
+  /**
+   * Internal: Add shortName to the list of options.
+   * Throws if the option is already registered in the given command context.
+   * or in the given command.
+   * `longName` may differ from `opt.longName`, e.g. for aliases.
+   *
+   * @private
+   * @see _addOption()
+   */
+  function _addShortOption(cmd, shortName, opt) {
+    if (!shortName)
+      return;
+    if (cmd.options[shortName]) {
+      throw new Error(`Duplicate assignment for short option ${shortName}`);
+    } else if (optionProcessor.options[shortName]) {
+      // This path is only taken if optString is for commands
+      optionProcessor.optionClashes.push({
+        option: shortName,
+        description: `Command '${cmd.longName}' has option clash with general options for: ${shortName}`
+      });
     }
-    return cmd;
+    cmd.options[shortName] = opt;
   }
 
   // Internal: Parse one command string like "F, toFoo". Return an object like this
@@ -275,7 +306,8 @@ function createOptionProcessor() {
       shortName,
       camelName: camelifyLongOption(longName),
       param,
-      validValues
+      validValues,
+      isAlias: false, // default
     }
   }
 

package/lib/checks/actionsFunctions.js

@@ -16,8 +16,8 @@ function checkActionOrFunction(art, artName, prop, path) {
   if (!(art.kind === 'action' || art.kind === 'function') && !art.actions)
     return;
 
-  // const isMultiSchema = this.options.toOdata.odataFormat === 'structured' &&
-  //   (this.options.toOdata.odataProxies || this.options.toOdata.odataXServiceRefs);
+  // const isMultiSchema = this.options.odataFormat === 'structured' &&
+  //   (this.options.odataProxies || this.options.odataXServiceRefs);
 
   const serviceName = this.csnUtils.getServiceName(artName);
   if (!serviceName)
@@ -85,9 +85,11 @@ function checkActionOrFunction(art, artName, prop, path) {
    * @param {string} actKind 'action' or 'function'
    */
   function checkReturns(returns, currPath, actKind) {
-    const finalReturnType = returns.type ? this.csnUtils.getFinalBaseType(returns.type) : returns;
+    const finalReturnType = returns.type ? this.csnUtils.getFinalBaseTypeWithProps(returns.type) : returns;
+    if (!finalReturnType)
+      return; // no type, e.g. `type of V:calculated`; already an error in `checkTypeOfHasProperType()`
 
-    if (this.csnUtils.isAssocOrComposition(finalReturnType)) {
+    if (this.csnUtils.isAssocOrComposition(finalReturnType.type)) {
       this.error(null, currPath, { '#': actKind },
                  {
                    std: 'An association is not allowed as this artifact\'s return type', // Not used
@@ -98,7 +100,7 @@ function checkActionOrFunction(art, artName, prop, path) {
 
     if (finalReturnType.items) // check array return type
       checkReturns.bind(this)(finalReturnType.items, currPath.concat('items'), actKind);
-    else // check if return type is user definited from the current service
+    else // check if return type is user defined from the current service
       checkUserDefinedType.bind(this)(finalReturnType, returns.type, currPath);
   }
 

package/lib/checks/annotationsOData.js

@@ -23,7 +23,7 @@ function checkCoreMediaTypeAllowence(member) {
     'cds.hana.CLOB': 1,
     'cds.hana.BINARY': 1,
   };
-  if (member['@Core.MediaType'] && member.type && !(this.csnUtils.getFinalBaseType(member.type) in allowedCoreMediaTypes)) {
+  if (member['@Core.MediaType'] && member.type && !(this.csnUtils.getFinalBaseTypeWithProps(member.type)?.type in allowedCoreMediaTypes)) {
     this.warning(null, member.$path, { names: [ 'Edm.String', 'Edm.Binary' ] },
                  'Element annotated with “@Core.MediaType” should be of a type mapped to $(NAMES)');
   }

package/lib/checks/cdsPersistence.js

@@ -14,6 +14,7 @@ function validateCdsPersistenceAnnotation(artifact, artifactName, prop, path) {
   if (artifact.kind === 'entity') {
     // filter for 'table', 'udf', 'calcview' === true
     const persistenceAnnos = [ '@cds.persistence.table', '@cds.persistence.udf', '@cds.persistence.calcview' ];
+    // TODO: Why not filter over persistenceAnnos, is shorter!
     const TableUdfCv = Object.keys(artifact).filter(p => persistenceAnnos.includes(p) && artifact[p]);
     if (TableUdfCv.length > 1)
       this.error(null, path, `Annotations ${ TableUdfCv.join(', ') } can't be used in combination`);

package/lib/checks/elements.js

@@ -36,10 +36,10 @@ function checkPrimaryKey(art) {
    */
   function checkIfPrimaryKeyIsOfGeoType(member, elemFqName, parentIsKey, parentPath) {
     if (member.key || parentIsKey) {
-      const finalBaseType = this.csnUtils.getFinalBaseType(member.type);
-      if (typeof finalBaseType === 'string' && isGeoTypeName(finalBaseType)) {
+      const finalBaseType = this.csnUtils.getFinalBaseTypeWithProps(member.type);
+      if (isGeoTypeName(finalBaseType?.type)) {
         this.error(null, parentPath || member.$path,
-                   { type: finalBaseType, name: elemFqName },
+                   { type: finalBaseType.type, name: elemFqName },
                    'Type $(TYPE) can\'t be used as primary key in element $(NAME)');
       }
       else if (finalBaseType && this.csnUtils.isStructured(finalBaseType)) {
@@ -63,7 +63,7 @@ function checkPrimaryKey(art) {
    */
   function checkIfPrimaryKeyIsArray(member, elemFqName, parentIsKey, parentPath) {
     if (member.key || parentIsKey) {
-      const finalBaseType = this.csnUtils.getFinalBaseType(member.type);
+      const finalBaseType = this.csnUtils.getFinalBaseTypeWithProps(member.type);
       if (member.items || (finalBaseType && finalBaseType.items)) {
         this.error(null, parentPath || member.$path, { name: elemFqName },
                    'Array-like type in element $(NAME) can\'t be used as primary key');
@@ -96,10 +96,10 @@ function checkVirtualElement(member) {
 
 /**
  * Checks whether managed associations
- * with cardinality 'to many' have an on-condition
- * and if managed associations have foreign keys.
+ * with cardinality 'to many' have an on-condition.
  *
  * @param {CSN.Artifact} art The artifact
+ * @todo this is a member validator, is it not?
  */
 function checkManagedAssoc(art) {
   forEachMemberRecursively(art, (member) => {

package/lib/checks/invalidTarget.js

@@ -26,7 +26,7 @@ function invalidTarget(member) {
       if (!target)
         throw new ModelError(`Expected target ${ mem.target }`);
       if (target.kind !== 'entity') {
-        const isAssoc = this.csnUtils.getFinalBaseType(member.type) !== 'cds.Composition';
+        const isAssoc = this.csnUtils.getFinalBaseTypeWithProps(member.type)?.type !== 'cds.Composition';
         this.error(
           null,
           member.$path,

package/lib/checks/nonexpandableStructured.js

@@ -21,7 +21,7 @@ function nonexpandableStructuredInExpression(parent, name, expression) {
       if (_art) {
         _art = resolveArtifactType.call(this, _art);
         // Paths of an expression may end on a structured element only if both operands in the expression end on a structured element
-        if (_art.elements && !validStructuredElement && $scope !== '$self') { // TODO: Use $self to navigate to struct
+        if (_art?.elements && !validStructuredElement && $scope !== '$self') { // TODO: Use $self to navigate to struct
           this.error(null, expression[i].$path, { elemref: { ref } },
                      'Unexpected usage of structured type $(ELEMREF)');
         }

package/lib/checks/queryNoDbArtifacts.js

@@ -3,7 +3,8 @@
 const { hasAnnotationValue, isPersistedOnDatabase, isBuiltinType } = require('../model/csnUtils');
 /**
  * Make sure that all source artifacts and association targets reach the database
- * (otherwise the view can't be activated), but only if the source artifact is NOT activated against the database
+ * (otherwise the view can't be activated), but only if the source artifact is NOT activated against the database // <- what does this mean?
+ *
  * Check the given query for:
  * - Associations-traversal over skipped/abstract things
  * - Associations (indirectly) using managed associations without foreign keys

package/lib/checks/selectItems.js

@@ -5,9 +5,13 @@ const { forEachGeneric } = require('../model/csnUtils');
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 /**
- * Validate select items of a query.
+ * Validate select items of a query. If a column reference starts with $self or $projection, it must not contain association steps.
+ * Furthermore, for to.hdbcds, window functions are not allowed.
+ *
+ * For to.hdbcds-hdbcds, structures and managed associations are not allowed as they are not flattened - @see rejectManagedAssociationsAndStructuresForHdbcdsNames
  *
  * @param {CSN.Query} query query object
+ * @todo Why do we care about this with $self?
  */
 function validateSelectItems(query) {
   const { SELECT } = query;

package/lib/checks/types.js

@@ -129,8 +129,8 @@ function checkTypeOfHasProperType(artOrElement, name, model, error, path, derive
   if (!artOrElement.type)
     return;
 
-  const { getFinalBaseType } = getUtils(model);
-  const typeOfType = getFinalBaseType(artOrElement.type, path);
+  const { getFinalBaseTypeWithProps } = getUtils(model);
+  const typeOfType = getFinalBaseTypeWithProps(artOrElement.type);
 
   if (typeOfType === null) {
     if (artOrElement.type.ref) {
@@ -157,6 +157,7 @@ function checkTypeOfHasProperType(artOrElement, name, model, error, path, derive
  * @param {CSN.Path} path the path to the element or the artifact
  * @param {string} name of the element or the artifact which is dubious
  * @param {boolean} isElement indicates whether we are dealing with an element or an artifact
+ * @todo Rename, is an error not a warning
  */
 function warnAboutMissingType(error, path, name, isElement = false) {
   error('check-proper-type', path, { art: name, '#': isElement ? 'elm' : 'std' }, {
@@ -173,6 +174,7 @@ function warnAboutMissingType(error, path, name, isElement = false) {
  *
  * @param {CSN.Artifact} artifact the artifact to check
  * @returns {boolean} indicates whether the artifact has type information
+ * @todo What is the point of isBuiltinType here if we check for artifact.type at the end?
  */
 function hasArtifactTypeInformation(artifact) {
   // When is what property set?

package/lib/checks/utils.js

@@ -31,7 +31,7 @@ function otherSideIsExpandableStructure(on, startIndex) {
   return false;
 
   /**
-   * Artifact is structured or a managed association/compoisition
+   * Artifact is structured or a managed association/composition
    *
    * @param {CSN.Artifact} art Artifact
    * @returns {boolean} True if expandable
@@ -49,7 +49,7 @@ function otherSideIsExpandableStructure(on, startIndex) {
  */
 function resolveArtifactType(art) {
   if (art && art.type && !isBuiltinType(art.type))
-    return this.getFinalBaseType(art);
+    return this.csnUtils.getFinalBaseTypeWithProps(art.type);
 
   return art;
 }

package/lib/checks/validator.js

@@ -103,8 +103,9 @@ const commonMemberValidators
   validateAssociationsInItems, checkForInvalidTarget,
   checkVirtualElement, checkElementTypeDefinitionHasType ];
 
+// TODO: checkManagedAssoc is a forEachMemberRecursively!
 const commonArtifactValidators = [ checkTypeDefinitionHasType, checkPrimaryKey, checkManagedAssoc ];
-
+// TODO: Does it make sense to run the on-condition check as part of a CSN validator?
 const commonQueryValidators = [ validateMixinOnCondition ];
 
 /**

package/lib/compiler/assert-consistency.js

@@ -118,8 +118,10 @@ function assertConsistency( model, stage ) {
         '$sources',
       ],
     },
-    location: {                 // location req if at least one property:
-      isRequired: parent => noSyntaxErrors() || Object.keys( parent ).length,
+    location: {
+      // every thing with a $location in CSN must have a XSN location even
+      // with syntax errors (currently even internal artifacts like $using):
+      isRequired: parent => noSyntaxErrors() || parent && parent.kind,
       kind: true,
       requires: [ 'file' ],     // line is optional in top-level location
       optional: [ 'line', 'col', 'endLine', 'endCol', '$notFound' ],
@@ -185,12 +187,16 @@ function assertConsistency( model, stage ) {
           // are missing the location property
           test: isDictionary( definition ),
           requires: [ 'kind', 'name' ],
-          optional: [ 'elements', '$autoElement', '$uncheckedElements', '_effectiveType', '_deps' ],
+          optional: [
+            'elements', '$autoElement', '$uncheckedElements',
+            '$requireElementAccess', '_effectiveType', '_deps',
+          ],
           schema: {
             kind: { test: isString, enum: [ 'builtin' ] },
             name: { test: isObject, requires: [ 'id', 'element' ] },
             $autoElement: { test: isString },
             $uncheckedElements: { test: isBoolean },
+            $requireElementAccess: { test: isBoolean },
             // missing location for normal "elements"
             elements: { test: TODO },
           },
@@ -217,8 +223,7 @@ function assertConsistency( model, stage ) {
     usings: {
       test: isArray(),
       requires: [ 'kind', 'location' ],
-      optional: [ 'name', 'extern', 'usings', '$annotations', 'fileDep' ],
-      // TODO: get rid of $annotations: []
+      optional: [ 'name', 'extern', 'usings', 'fileDep' ],
     },
     extern: {
       requires: [ 'location', 'path' ],
@@ -304,7 +309,6 @@ function assertConsistency( model, stage ) {
       kind: 'element',
       test: isDictionary( definition ), // definition since redef
       requires: [ 'location', 'name' ],
-      optional: [ '$annotations' ], // TODO: get rid of annos: []
     },
     orderBy: { inherits: 'value', test: isArray( expression ) },
     sort: { test: locationVal( isString ), enum: [ 'asc', 'desc' ] },
@@ -449,11 +453,11 @@ function assertConsistency( model, stage ) {
     '@': {
       kind: true,
       inherits: 'value',
-      optional: [ 'name', '_block', '$priority', '$duplicate', '$inferred', '$duplicates' ],
+      optional: [ 'name', '_block', '$priority', '$inferred', '$duplicates', '$errorReported' ],
       // TODO: name requires if not in parser?
     },
-    $priority: { test: TODO }, // TODO: rename to $priority
-    $annotations: { parser: true, kind: true, test: TODO },
+    $priority: { test: TODO },
+    $annotations: { parser: true, kind: true, test: TODO }, // deprecated, still there for cds-lsp
     name: {
       isRequired: stageParser && (() => false), // not required in parser
       kind: true,
@@ -468,7 +472,7 @@ function assertConsistency( model, stage ) {
       ],
     },
     absolute: { test: isString },
-    variant: { test: TODO }, // TODO: not set in CDL parser, only in $annotations
+    variant: { test: TODO }, // TODO: not set in CDL parser
     element: { test: TODO }, // TODO: { test: isString },
     action: { test: isString },
     param: { test: isString },
@@ -581,6 +585,7 @@ function assertConsistency( model, stage ) {
     // (it can contain the artifact itself with no/failed autoexposure):
     _descendants: { kind: [ 'entity' ], test: isDictionary( isArray( TODO ) ) },
 
+    $errorReported: { parser: true, kind: true, test: isString },     // to avoid duplicate messages
     $duplicates: { parser: true, kind: true, test: TODO }, // array of arts or true
     $extension: { kind: true, test: TODO }, // TODO: introduce $applied instead or $status
     $inferred: { parser: true, kind: true, test: isString },

package/lib/compiler/builtins.js

@@ -1,7 +1,7 @@
 // The builtin artifacts of CDS
 
 // TODO: split this file
-// - in base/: common definitions
+// - in base/: common definitions, datetime formats
 // - in compiler/: XSN-specific
 // - in ?: CSN-specific
 
@@ -76,19 +76,92 @@ const functionsWithoutParens = [
   'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
 ];
 
-const specialFunctions = {
+const specialFunctions = compileFunctions( {
+  '': [                         // the default
+    {
+      intro: [ 'ALL', 'DISTINCT' ],
+      introMsg: [],             // do not list them in code completion
+    },
+    {},
+  ],
   ROUND: [
     null, null, {               // 3rd argument: rounding mode
-      ROUND_HALF_UP: 'argFull',
-      ROUND_HALF_DOWN: 'argFull',
-      ROUND_HALF_EVEN: 'argFull',
-      ROUND_UP: 'argFull',
-      ROUND_DOWN: 'argFull',
-      ROUND_CEILING: 'argFull',
-      ROUND_FLOOR: 'argFull',
+      expr: [ 'ROUND_HALF_UP', 'ROUND_HALF_DOWN', 'ROUND_HALF_EVEN',
+        'ROUND_UP', 'ROUND_DOWN', 'ROUND_CEILING', 'ROUND_FLOOR' ],
     },
   ],
-};
+  TRIM: [
+    {
+      intro: [ 'LEADING', 'TRAILING', 'BOTH' ],
+      expr: [ 'LEADING', 'TRAILING', 'BOTH' ],
+      separator: [ 'FROM' ],
+    },
+  ],
+  EXTRACT: [
+    {
+      expr: [ 'YEAR', 'MONTH', 'DAY', 'HOUR', 'MINUTE', 'SECOND' ],
+      separator: [ 'FROM' ],
+    },
+  ],
+  COUNT: [
+    {
+      expr: [ '*' ],
+      intro: [ 'ALL', 'DISTINCT' ],
+    },
+  ],
+  MIN: 'COUNT',
+  MAX: 'COUNT',
+  SUM: 'COUNT',
+  AVG: 'COUNT',
+  STDDDEV: 'COUNT',
+  VAR: 'COUNT',
+  LOCATE_REGEXPR: [
+    {
+      intro: [ 'START', 'AFTER' ],
+      separator: [ 'FLAG', 'IN', 'FROM', 'OCCURRENCE', 'GROUP' ],
+    },
+  ],
+  OCCURRENCES_REGEXPR: [
+    {
+      separator: [ 'FLAG', 'IN', 'FROM' ],
+    },
+  ],
+  REPLACE_REGEXPR: [
+    {
+      separator: [ 'FLAG', 'IN', 'WITH', 'FROM', 'OCCURRENCE' ],
+      expr: [ 'ALL' ],
+    },
+  ],
+  SUBSTRING_REGEXPR: [
+    {
+      separator: [ 'FLAG', 'IN', 'FROM', 'OCCURRENCE', 'GROUP' ],
+    },
+  ],
+} );
+
+function compileFunctions( special ) {
+  const compiled = {};
+  for (const [ name, val ] of Object.entries( special ))
+    compiled[name] = (typeof val === 'string' ? special[val] : val).map( compileArg );
+  return compiled;
+}
+
+function compileArg( src ) {
+  if (!src)
+    return src;
+  const tgt = {
+    intro: src.intro || [],
+    expr: src.expr || [],
+    separator: src.separator || [],
+  };
+  for (const generic of [ 'intro', 'expr', 'separator' ]) { // intro before expr!
+    for (const token of src[generic] || [])
+      tgt[token] = generic;
+  }
+  if (tgt.intro)             // same token could be in both 'expr' and 'intro':
+    tgt.introMsg = src.introMsg || tgt.intro.filter( token => tgt[token] === 'intro' );
+  return tgt;
+}
 
 /**
  * Variables that have special meaning in CDL/CSN.
@@ -106,17 +179,58 @@ const magicVariables = {
     elements: {
       from: {}, to: {},
     },
+    // Require that elements are accessed, i.e. no $at, only $at.<element>.
+    $requireElementAccess: true,
   },
   $now: {}, // Dito
   $session: {
     // In ABAP CDS session variables are accessed in a generic way via
     // the pseudo variable $session.
     $uncheckedElements: true,
+    $requireElementAccess: true,
   },
 };
 
 // see lib/render/renderUtil.js for DB-specific magic vars, specified in CAP Cds via function
 
+/**
+ * Patterns for literal token tests and creation.  The value is a map from the
+ * `prefix` argument of function `quotedliteral` to the following properties:
+ *  - `test_msg`: error message which is issued if `test_fn` or `test_re` fail.
+ *  - `test_fn`: function called with argument `value`, fails falsy return value
+ *  - `test_re`: regular expression, fails if it does not match argument `value`
+ *  - `unexpected_msg`: error message which is issued if `unexpected_char` matches
+ *  - `unexpected_char`: regular expression matching an illegal character in `value`,
+ *    the error location is only correct for a literal <prefix>'<value>'
+ *  - `literal`: the value which is used instead of `prefix` in the AST
+ * TODO: we might do a range check (consider leap seconds, i.e. max value 60),
+ *       but always allow Feb 29 (no leap year computation)
+ */
+const quotedLiteralPatterns = {
+  x: {
+    test_variant: 'uneven-hex',
+    test_fn: (str => Number.isInteger(str.length / 2)),
+    unexpected_variant: 'invalid-hex',
+    unexpected_char: /[^0-9a-f]/i,
+    json_type: 'string',
+  },
+  time: {
+    test_variant: 'time',
+    test_re: /^[0-9]{1,2}:[0-9]{1,2}(:[0-9]{1,2})?$/,
+    json_type: 'string',
+  },
+  date: {
+    test_variant: 'date',
+    test_re: /^[0-9]{4}-[0-9]{1,2}-[0-9]{1,2}$/,
+    json_type: 'string',
+  },
+  timestamp: {
+    test_variant: 'timestamp',
+    test_re: /^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}(:[0-9]{2}(\.[0-9]{1,7})?)?$/,
+    json_type: 'string',
+  },
+};
+
 /** All types belong to one category. */
 const typeCategories = {
   string: [],
@@ -286,6 +400,8 @@ function initBuiltins( model ) {
         art.$autoElement = magic.$autoElement;
       if (magic.$uncheckedElements)
         art.$uncheckedElements = magic.$uncheckedElements;
+      if (magic.$requireElementAccess)
+        art.$requireElementAccess = magic.$requireElementAccess;
 
       createMagicElements( art, magic.elements );
       if (options.variableReplacements)
@@ -325,6 +441,7 @@ module.exports = {
   typeParameters,
   functionsWithoutParens,
   specialFunctions,
+  quotedLiteralPatterns,
   initBuiltins,
   isInReservedNamespace,
   isBuiltinType,

package/lib/compiler/define.js

@@ -390,14 +390,14 @@ function define( model ) {
     setLink( vocab, '_block', block );
     const { name } = vocab;
     if (!name.absolute)
-      name.absolute = prefix + name.path.map( id => id.id ).join('.');
+      name.absolute = prefix + pathName( name.path );
     dictAdd( model.vocabularies, name.absolute, vocab );
   }
 
   // Phase 2 ("init") --------------------------------------------------------
 
   function checkRedefinition( art ) {
-    if (!art.$duplicates)
+    if (!art.$duplicates || art.$errorReported === 'syntax-duplicate-extend')
       return;
     if (art._main) {
       error( 'duplicate-definition', [ art.name.location, art ], {
@@ -505,13 +505,13 @@ function define( model ) {
       initParentLink( parent, definitions );
     }
     if (art.kind !== 'namespace' &&
-        isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' )) {
+        isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' )) {
       let p = parent;
       while (p && kindProperties[p.kind].artifacts)
         p = p._parent;
       if (p) {
         error( 'subartifacts-not-supported', [ art.name.location, art ],
-               { art: p, prop: 'deprecated.generatedEntityNameWithUnderscore' },
+               { art: p, prop: 'deprecated._generatedEntityNameWithUnderscore' },
                // eslint-disable-next-line max-len
                'With the option $(PROP), no sub artifact can be defined for a non-context/service $(ART)' );
       }
@@ -670,6 +670,8 @@ function define( model ) {
    * @param {object} exprOrPathElement starts w/ an expr but then subelem from .path or .where.args
    */
   function approveExistsInChildren(exprOrPathElement) {
+    if (!exprOrPathElement) // may be null in case of parse error
+      return;
     if (exprOrPathElement.$expected === 'exists')
       exprOrPathElement.$expected = 'approved-exists';
     // Drill down