@sap/cds-compiler 3.6.2 → 3.8.0

package/lib/checks/{emptyOrOnlyVirtual.js → hasPersistedElements.js}

@@ -1,8 +1,10 @@
 'use strict';
 
-const { isPersistedOnDatabase } = require('../model/csnUtils.js');
 // Only to be used with validator.js - a correct this value needs to be provided!
 // not relevant for odata - entities need to be checked at the end of the transformation
+
+const { isPersistedOnDatabase } = require('../model/csnUtils.js');
+
 /**
  * Ensure that empty/only virtual entities do not reach the db.
  *
@@ -11,22 +13,24 @@ const { isPersistedOnDatabase } = require('../model/csnUtils.js');
  * @param {string} prop Property being looped over
  * @param {CSN.Path} path Path to the artifact
  */
-function validateEmptyOrOnlyVirtual( artifact, artifactName, prop, path ) {
+function validateHasPersistedElements( artifact, artifactName, prop, path ) {
   if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact)) {
     if (!artifact.elements || !hasRealElements(artifact.elements))
-      this.error('def-missing-element', path, { '#': artifact.query ? 'view' : 'std' });
+      // TODO: Maybe check if there are only calc elements and adapt the message?
+      this.error('def-missing-element', path, { '#': ( artifact.query || artifact.projection ) ? 'view' : 'std' });
   }
 }
 
 /**
- * Check if the provided elements contain elements that will be created on the db.
+ * Check if the provided elements contain elements that will be created on the database.
+ * This includes virtual and calculated elements.
  *
  * @param {CSN.Elements} elements Elements to look through
  * @returns {boolean} True if something would be created on the db from these elements.
  */
 function hasRealElements( elements ) {
   for (const element of Object.values(elements)) {
-    if (!element.virtual) {
+    if (!element.virtual && !element.value) {
       if (element.elements) {
         if (hasRealElements(element.elements))
           return true;
@@ -41,4 +45,4 @@ function hasRealElements( elements ) {
 }
 
 
-module.exports = validateEmptyOrOnlyVirtual;
+module.exports = validateHasPersistedElements;

package/lib/checks/invalidTarget.js

@@ -55,7 +55,7 @@ function invalidTarget( member ) {
 
   if (
     this.artifact &&
-    (this.artifact.kind === 'entity' || this.artifact.query) &&
+    this.artifact.kind === 'entity' &&
     member.$path[2] === 'elements'
   )
     checkForInvalidTarget(member);

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 || _art?.keys && (i === 0 || expression[i - 1] !== 'exists')) && !validStructuredElement && $scope !== '$self') { // TODO: Use $self to navigate to struct
+        if ((_art?.elements || _art?.keys && (i === 0 || expression[i - 1] !== 'exists')) && !validStructuredElement && ($scope !== '$self' || $scope === '$self' && ref.length > 1)) { // TODO: Use $self to navigate to struct
           this.error('ref-unexpected-structured',
                      name === 'on' ? [ ...parent.$path, name, i ] : expression[i].$path,
                      { '#': 'std', elemref: { ref } } );

package/lib/checks/onConditions.js

@@ -83,16 +83,18 @@ function validateOnCondition( member, memberName, property, path ) {
           if (_links[j].art.target && !((_links[j].art === member) || ref[j] === '$self' || ref[j] === '$projection' || (validDollarSelf && j === _links.length - 1))) {
             if (_links[j].art.on) {
               // It's an unmanaged association - traversal is always forbidden
-              this.error(null, csnPath, { id, elemref }, 'ON-conditions can\'t follow unmanaged associations, step $(ID) of path $(ELEMREF)');
+              this.error('ref-unexpected-navigation', csnPath, { '#': 'unmanaged', id, elemref });
             }
             else {
               // It's a managed association - access of the foreign keys is allowed
               const nextRef = ref[j + 1].id || ref[j + 1];
-              if (!_links[j].art.keys.some(r => r.ref[0] === nextRef))
-                this.error(null, csnPath, { id, elemref }, 'ON-conditions can only follow managed associations to the foreign keys of the managed association, step $(ID) of path $(ELEMREF)');
+              if (!_links[j].art.keys.some(r => r.ref[0] === nextRef)) {
+                this.error('ref-unexpected-navigation', csnPath, {
+                  '#': 'std', id, elemref, name: nextRef,
+                });
+              }
             }
           }
-
           if (_links[j].art.virtual)
             this.error(null, csnPath, { id, elemref }, 'Virtual elements can\'t be used in ON-conditions, step $(ID) of path $(ELEMREF)');
 
@@ -113,11 +115,11 @@ function validateOnCondition( member, memberName, property, path ) {
             // 2) Path ends on an association (managed or unmanaged) and the other operand is a '$self'
 
             // If this path ends structured or on an association, perform the check:
-            if ((type.target) &&
-             !( /* 1) */ (type.target && type.keys) && validStructuredElement ||
-             /* 2) */ (type.target && validDollarSelf)) &&
-             !type.virtual) {
-            // Do nothing - handled by lib/checks/nonexpandableStructured.js
+            if (
+              ((type.target && type.keys || type.elements) && validStructuredElement ||
+              (type.target && validDollarSelf)) && !type.virtual
+            ) {
+              // Do nothing - handled by lib/checks/nonexpandableStructured.js
             }
             else if (type.items && !type.virtual) {
               this.error(null, onPath, { elemref: { ref } },
@@ -127,6 +129,10 @@ function validateOnCondition( member, memberName, property, path ) {
               this.error(null, onPath, { elemref: { ref } },
                          'Virtual elements can\'t be used in ON-conditions, path $(ELEMREF)');
             }
+            else if (type.on) {
+              // Path leaf is an unmanaged association, can't use an unmanaged assoc as operand
+              this.error('ref-unexpected-navigation', onPath, { '#': 'unmanagedleaf', id: logReady(ref[ref.length - 1]), elemref: { ref } });
+            }
           }
         }
       }

package/lib/checks/sql-snippets.js

@@ -18,7 +18,7 @@ function checkSqlAnnotationOnElement( member, memberName, prop, path ) {
     this.message('anno-invalid-sql-element', path, { anno: 'sql.prepend' }, 'Annotation $(ANNO) can\'t be used on elements' );
 
   if (member['@sql.append']) {
-    if (this.artifact.query)
+    if (this.artifact.query || this.artifact.projection)
       this.message('anno-invalid-sql-view-element', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on elements in views' );
     else if (this.csnUtils.isStructured(member))
       this.message('anno-invalid-sql-struct', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on structured elements' );
@@ -57,7 +57,7 @@ function checkSqlAnnotationOnArtifact( artifact, artifactName ) {
       this.message('anno-invalid-sql-kind', [ 'definitions', artifactName ], { name: '@sql.append', kind: artifact.kind }, 'Annotation $(NAME) can\'t be used on an artifact of kind $(KIND)' );
   }
   else if (artifact['@sql.prepend']) {
-    if (artifact.query)
+    if (artifact.query || artifact.projection)
       this.message('anno-invalid-sql-view', [ 'definitions', artifactName ], { name: '@sql.prepend' }, 'Annotation $(NAME) can\'t be used on views' );
     else
       checkValidAnnoValue(artifact, '@sql.prepend', [ 'definitions', artifactName ], this.error, this.options);

package/lib/checks/types.js

@@ -51,7 +51,11 @@ function checkElementTypeDefinitionHasType( member, memberName, prop, path ) {
   // Computed elements, e.g. "1+1 as foo" in a view don't have a valid type and
   // are skipped here.  References to such columns are checked further below.
   const parent = this.csn.definitions[path[1]];
-  if (!parent.projection && !parent.query && !hasArtifactTypeInformation(member)) {
+
+  // should only happen with csn input, not in cdl
+  // calculated elements may not have a .type (requires beta flag)
+  if (!member.value &&
+      !parent.projection && !parent.query && !hasArtifactTypeInformation(member)) {
     errorAboutMissingType(this.error, path, memberName, true);
     return;
   }

package/lib/checks/validator.js

@@ -12,7 +12,7 @@ const { validateSelectItems } = require('./selectItems');
 const { rejectParamDefaultsInHanaCds, warnAboutDefaultOnAssociationForHanaCds } = require('./defaultValues');
 const validateCdsPersistenceAnnotation = require('./cdsPersistence');
 const checkUsedTypesForAnonymousAspectComposition = require('./managedInType');
-const checkForEmptyOrOnlyVirtual = require('./emptyOrOnlyVirtual');
+const validateHasPersistedElements = require('./hasPersistedElements');
 const checkForHanaTypes = require('./checkForTypes');
 const checkForParams = require('./parameters');
 // forOdata
@@ -30,7 +30,8 @@ const {
   checkTypeIsScalar, checkDecimalScale,
 } = require('./types');
 const {
-  checkPrimaryKey, checkVirtualElement, checkManagedAssoc, checkRecursiveTypeUsage,
+  checkPrimaryKey, checkVirtualElement, checkManagedAssoc,
+  checkRecursiveTypeUsage, rejectAnnotationsOnCalcElement,
 } = require('./elements');
 const checkForInvalidTarget = require('./invalidTarget');
 const { validateAssociationsInItems } = require('./arrayOfs');
@@ -54,6 +55,8 @@ const forRelationalDBMemberValidators
   warnAboutDefaultOnAssociationForHanaCds,
   // sql.prepend/append
   checkSqlAnnotationOnElement,
+  // no temporal annotations on calc elements
+  rejectAnnotationsOnCalcElement,
 ];
 
 const forRelationalDBArtifactValidators
@@ -61,7 +64,7 @@ const forRelationalDBArtifactValidators
   // @cds.persistence has no impact on odata
   validateCdsPersistenceAnnotation,
   // virtual items are not persisted on the db
-  checkForEmptyOrOnlyVirtual,
+  validateHasPersistedElements,
   // sql.prepend/append
   checkSqlAnnotationOnArtifact,
 ];
@@ -254,6 +257,7 @@ function forOdata( csn, that ) {
                        }
                      }
                    ),
+                   // eslint-disable-next-line sonarjs/no-empty-collection
                    forOdataQueryValidators.concat(commonQueryValidators),
                    {
                      skipArtifact: this.isExternalServiceMember,

package/lib/compiler/assert-consistency.js

@@ -72,7 +72,7 @@ const { locationString, hasErrors } = require('../base/messages');
 // Properties that can appear where a type can have type arguments.
 const typeProperties = [
   'type', '$typeArgs', 'length', 'precision', 'scale', 'srid',
-  '_effectiveType',
+  '_effectiveType', '$effectiveSeqNo',
 ];
 
 class InternalConsistencyError extends Error {
@@ -191,8 +191,8 @@ function assertConsistency( model, stage ) {
           test: isDictionary( definition ),
           requires: [ 'kind', 'name' ],
           optional: [
-            'elements', '$autoElement', '$uncheckedElements',
-            '$requireElementAccess', '_effectiveType', '_deps',
+            'elements', '$autoElement', '$uncheckedElements', '_origin', '_extensions',
+            '$requireElementAccess', '_effectiveType', '$effectiveSeqNo', '_deps',
           ],
           schema: {
             kind: { test: isString, enum: [ 'builtin' ] },
@@ -250,18 +250,17 @@ function assertConsistency( model, stage ) {
         schema: { args: { inherits: 'query', test: isArray( query ) } },
         requires: [ 'op', 'location', 'args' ],
         optional: [
-          'quantifier', 'orderBy', 'limit', '_leadingQuery',
-          'name', '$parens', 'kind', '_parent', '_main', '_effectiveType', // in FROM
+          'quantifier', 'orderBy', 'limit', 'name', '$parens', 'kind',
+          '_parent', '_main', '_leadingQuery', '_effectiveType', '$effectiveSeqNo', // in FROM
         ],
       },
       select: {                   // sub query
         requires: [ 'op', 'location', 'from' ],
         optional: [
           'name', '$parens', 'quantifier', 'mixin', 'excludingDict', 'columns', 'elements', '_deps',
-          'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit',
-          '_projections', '_block', '_parent', '_main', '_effectiveType', '$expand',
+          'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit', '_origin', '_block',
+          '_projections', '_parent', '_main', '_effectiveType', '$effectiveSeqNo', '$expand',
           '$tableAliases', 'kind', '_$next', '_combined', '$inlines', '_status',
-          '_extension', // for unapplied extensions
         ],
       },
       none: { optional: () => true }, // parse error
@@ -285,7 +284,7 @@ function assertConsistency( model, stage ) {
           'elements', '_origin', '_joinParent', '$joinArgsIndex', '$syntax',
           '$parens', '_status', // TODO: only in from
           'scope', '_artifact', '$inferred', 'kind',
-          '_effectiveType',         // TODO:check this
+          '_effectiveType', '$effectiveSeqNo',         // TODO:check this
           '$duplicates', // In JOIN if both sides are the same.
         ],
       },
@@ -293,9 +292,10 @@ function assertConsistency( model, stage ) {
         requires: [ 'query', 'location' ],
         optional: [
           '$parens',
-          'kind', 'name', '_block', '_parent', '_main',
-          '_effectiveType', 'elements', '_origin', '_joinParent', '$joinArgsIndex',
+          'kind', 'name', '_block', '_parent', '_main', 'elements',
+          '_effectiveType', '$effectiveSeqNo', '_origin', '_joinParent', '$joinArgsIndex',
           '$duplicates', // duplicate query in FROM clause
+          '$inferred', // table alias with $inferred: '$internal'
         ],
       },
       none: { optional: () => true }, // parse error
@@ -340,7 +340,7 @@ function assertConsistency( model, stage ) {
       optional: [
         'path', 'elements', '_outer', '_parent', '_main', '_block', 'kind',
         'scope', '_artifact', '$inferred', '$expand', '$inCycle', '$tableAliases', '_$next',
-        '_effectiveType',           // by propagation
+        '_origin', '_effectiveType', '$effectiveSeqNo', '_extensions',
       ],
     },
     target: {
@@ -373,7 +373,7 @@ function assertConsistency( model, stage ) {
       // required to be set by Core Compiler even with parse errors
       test: isString,
       enum: [
-        'context', 'service', 'entity', 'type', 'aspect', 'const', 'annotation',
+        'context', 'service', 'entity', 'type', 'aspect', 'annotation',
         'element', 'enum', 'action', 'function', 'param', 'key', 'event',
         'annotate', 'extend', '$column',
         'select', '$join', 'mixin',
@@ -389,14 +389,18 @@ function assertConsistency( model, stage ) {
       kind: [ 'entity', 'view', 'type', 'aspect' ],
       test: isString,            // CSN parser should check for 'entity', 'view', 'projection'
     },
+    $tokenTexts: {
+      parser: true,
+      test: isString,
+    },
     value: {
       optional: [
         'location', '$inferred', 'sort', 'nulls',
         'param', 'scope', // for dynamic parameter '?'
-        // through cast() with enum through CSN->XSN
-        // TODO: re-check #9225, this should be directly in the query element,
-        // not inside value, no `enum` inside `cast`!
-        'elements', 'items', 'enum', '$expand', 'target',
+        // A2J wrongly propagates the following into a CAST of the CSN passed to compileX:
+        'elements', 'items', 'enum',
+        // CSN parser may let these properties slip through to XSN, even if input is invalid.
+        'args', 'op', 'func', 'suffix',
       ],
 
       kind: true,
@@ -446,6 +450,8 @@ function assertConsistency( model, stage ) {
       requires: [ 'location' ],
       optional: [
         'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicates', 'upTo',
+        // expressions as annotation values
+        '$tokenTexts', 'op', 'args', 'func',
       ],
       // TODO: restrict path to #simplePath
     },
@@ -473,7 +479,13 @@ function assertConsistency( model, stage ) {
     '@': {
       kind: true,
       inherits: 'value',
-      optional: [ 'name', '_block', '$priority', '$inferred', '$duplicates', '$errorReported' ],
+      optional: [
+        'name', '_block', '$priority', '$inferred', '$duplicates', '$errorReported',
+        // annotation values
+        '$tokenTexts',
+        // CSN parser may let these properties slip through to XSN, even if input is invalid.
+        'args', 'op', 'func', 'suffix',
+      ],
       // TODO: name requires if not in parser?
     },
     $priority: { test: isOneOf([ undefined, false, 'extend', 'annotate' ]) },
@@ -497,7 +509,7 @@ function assertConsistency( model, stage ) {
     action: { test: isString },
     param: { test: TODO },
     alias: { test: isString },
-    expectedKind: { kind: [ 'extend' ], inherits: 'kind' },
+    expectedKind: { kind: [ 'extend' ], test: locationVal( isString ) },
     virtual: { kind: true, test: locationVal() },
     key: { kind: true, test: locationVal(), also: [ null, undefined ] },
     masked: { kind: true, test: locationVal() },
@@ -515,9 +527,9 @@ function assertConsistency( model, stage ) {
       optional: [
         'enum',
         'elements', 'cardinality', 'target', 'on', 'foreignKeys', 'items',
-        '_outer', '_effectiveType', 'notNull', '_parent',
+        '_outer', '_effectiveType', '$effectiveSeqNo', 'notNull', '_parent',
         '_origin', '_block', '$inferred', '$expand', '$inCycle', '_deps',
-        '$syntax',
+        '$syntax', '_extensions',
         '_status', '_redirected',
         ...typeProperties,
       ],
@@ -550,6 +562,7 @@ function assertConsistency( model, stage ) {
     _artifact: { test: TODO },
     _navigation: { test: TODO },
     _effectiveType: { kind: true, test: TODO },
+    $effectiveSeqNo: { kind: true, test: isNumber },
     _joinParent: { test: TODO },
     $joinArgsIndex: { test: isNumber },
     _outer: { test: TODO },              // for returns/items
@@ -565,24 +578,25 @@ function assertConsistency( model, stage ) {
         '$tableAliases', '$inlines',
       ],
       optional: [
-        '_effectiveType', '$parens',
+        '_effectiveType', '$effectiveSeqNo', '$parens',
         '_deps', '$expand',
         // query specific
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
-        'limit', '_status',
-        '_extension', // for unapplied extensions
+        'limit', '_status', '_origin', '_effectiveType', '$effectiveSeqNo',
       ],
     },
     _leadingQuery: { kind: true, test: TODO },
     $replacement: { kind: true, test: TODO }, // for smart * in queries
-    _origin: { kind: [ 'entity' ], test: TODO },
+    _origin: { kind: true, test: TODO },
+    _calcOrigin: { kind: true, test: TODO },
     _pathHead: { kind: [ 'element', undefined ], test: TODO }, // column or * (wildcard)
-    _from: { kind: true, test: TODO }, // all table refs necessary to compute elements
+    _from: { kind: true, test: TODO }, // TODO: not necessary anymore ?
     // array of $tableAlias (or includes) for explicit and implicit redirection:
     _redirected: { kind: true, test: TODO },
     // ...array of table aliases for targets from orig to new
     _$next: { kind: true, test: TODO }, // next lexical search environment for values
+    _extensions: { kind: true, test: TODO }, // for collecting extend/annotate on artifact
     _extend: { kind: true, test: TODO }, // for collecting extend/annotate on artifact
     _annotate: { kind: true, test: TODO }, // for collecting extend/annotate on artifact
     _extension: { kind: true, test: TODO }, // on artifact to its "super extend/annotate" statement
@@ -612,6 +626,7 @@ function assertConsistency( model, stage ) {
       parser: true,
       kind: true,
       test: isOneOf([
+        '',                     // constructed “super annotate” statement
         // Uppercase values are used in logic, lowercase value are "just for us", i.e.
         // debugging or to add properties such as $generated in Universal CSN.
         // However, that is no longer true. For example, `autoexposed` is used in populate.js
@@ -623,6 +638,7 @@ function assertConsistency( model, stage ) {
 
         '$autoElement', // for magicVars: $user is automatically changed to $user.id
         '$generated', // compiler generated annotations, e.g. @Core.Computed
+        '$internal', // compiler internal; must not reach CSN output
         '*', // inferred from query wildcard
         'as', // query alias name
         'aspect-composition',

package/lib/compiler/base.js

@@ -29,28 +29,31 @@ const kindProperties = {
   type: { elements: propExists, enum: propExists, include: true },
   aspect: { elements: propExists, actions: true, include: true },
   annotation: { elements: propExists, enum: propExists },
-  enum: { normalized: 'element' },
+  enum: { normalized: 'element', dict: 'enum' },
   element: { elements: propExists, enum: propExists, dict: 'elements' },
   mixin: { normalized: 'alias' },
   action: {
     params: () => false, elements: () => false, enum: () => false, dict: 'actions',
   }, // no extend params, only annotate
   function: {
-    params: () => false, elements: () => false, enum: () => false, normalized: 'action',
+    params: () => false,
+    elements: () => false,
+    enum: () => false,
+    normalized: 'action',
+    dict: 'actions',
   }, // no extend params, only annotate
   key: { normalized: 'element' },
   param: { elements: () => false, enum: () => false, dict: 'params' },
   source: { artifacts: true },  // TODO -> $source
   using: {},
   extend: {
-    isExtension: true,
     noDep: 'special',
     elements: true, /* only for parse-cdl */
     actions: true,  /* only for parse-cdl */
     enum: true,     /* only for parse-cdl */
   },
   annotate: {
-    isExtension: true, noDep: 'special', elements: true, enum: true, actions: true, params: true,
+    noDep: 'special', elements: true, enum: true, actions: true, params: true,
   },
   builtin: {},                  // = CURRENT_DATE, TODO: improve
   $parameters: {},              // $parameters in query entities
@@ -61,7 +64,50 @@ function propExists( prop, parent ) {
   return (obj.items || obj.targetAspect || obj)[prop];
 }
 
+// Return the "old style" name structure with `absolute`, `action`, `param`,
+// `element`. Later we also need to add `select` and `alias`.
+// (Currently not needed, as only used for extend and annotate statements.)
+function getArtifactName( art ) {
+  if (!art.name || art.name.absolute)
+    return art.name;
+  // extend and annotate statement already have "sparse" names → calculate old one
+  const link = art.name._artifact;
+  const namePath = [];
+  while (art._main && !art.name.absolute) { // until we hit an old-style name or the main artifact
+    namePath.push( art );
+    art = art._parent;
+  }
+  namePath.reverse();
+  const name = { ...art.name };
+  for (const np of namePath) {
+    const prop = getMemberNameProp( np, np.kind );
+    name[prop] = (name[prop]) ? `${ name[prop] }.${ np.name.id }` : np.name.id;
+    name.id = np.name.id;
+    name.location = np.name.location;
+  }
+  if (link !== undefined)
+    Object.defineProperty( name, '_artifact', { value: link, configurable: true, writable: true } );
+  return name;
+}
+
+// TODO: probably store this prop in name
+function getMemberNameProp( elem, kind ) {
+  if (kind !== 'annotate' && kind !== 'extend')
+    return kindProperties[kind]?.normalized || kind;
+  let obj = elem._parent;
+  if (obj.params || obj.returns)
+    return 'param';
+  if (obj.actions)
+    return 'action';
+  while (obj.items)
+    obj = obj.items;
+  if (obj.elements || obj.enum)
+    return 'element';
+  return 'id';
+}
+
 module.exports = {
   dictKinds,
   kindProperties,
+  getArtifactName,
 };

package/lib/compiler/builtins.js

@@ -10,6 +10,7 @@
 const { builtinLocation } = require('../base/location');
 const { setLink: setProp } = require('./utils');
 
+// TODO: make type parameters a dict
 const core = {
   String: { parameters: [ 'length' ], category: 'string' },
   LargeString: { category: 'string' },
@@ -199,7 +200,16 @@ const magicVariables = {
   },
 };
 
-// see lib/render/renderUtil.js for DB-specific magic vars, specified in CAP Cds via function
+// see lib/render/renderUtil.js for DB-specific magic vars, specified in CAP CDS  via function
+
+const dateRegEx = /^(-?\d{4})-(\d{1,2})-(\d{1,2})$/;
+//                      YYYY -     MM  -   dd
+const timeRegEx = /^T?(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?(?:Z|[+-]\d{2}(?::\d{2})?)?$/;
+//                  T     HH   :    mm      :    ss         TZD
+// eslint-disable-next-line max-len
+const timestampRegEx = /^(-?\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(\.\d{1,7})?)?(?:Z|[+-]\d{2}(?::\d{2})?)?$/;
+//                          YYYY  -  MM   -  dd    T    HH   :   mm     :  ss     . fraction     TZD
+const numberRegEx = /^[ \t]*[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]\d+)?[ \t]*$/i;
 
 /**
  * Patterns for literal token tests and creation.  The value is a map from the
@@ -227,7 +237,7 @@ const quotedLiteralPatterns = {
     test_variant: 'time',
     test_fn: (x) => {
       // Leading `T` allowed in ISO 8601.
-      const match = x.match( /^T?(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?$/ );
+      const match = x.match( timeRegEx );
       return match !== null && checkTime( match[1], match[2], match[3] );
     },
     json_type: 'string',
@@ -235,7 +245,7 @@ const quotedLiteralPatterns = {
   date: {
     test_variant: 'date',
     test_fn: (x) => {
-      const match = x.match( /^(-?\d{4})-(\d{1,2})-(\d{1,2})$/ );
+      const match = x.match( dateRegEx );
       return match !== null && checkDate( match[1], match[2], match[3] );
     },
     json_type: 'string',
@@ -243,8 +253,7 @@ const quotedLiteralPatterns = {
   timestamp: {
     test_variant: 'timestamp',
     test_fn: (x) => {
-      // eslint-disable-next-line max-len
-      const match = x.match( /^(-?\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(\.\d{1,7})?)?$/ );
+      const match = x.match( timestampRegEx );
       return match !== null && checkDate( match[1], match[2], match[3] ) &&
         checkTime( match[4], match[5], match[6] );
     },
@@ -259,7 +268,7 @@ const quotedLiteralPatterns = {
   },
   number: {
     test_variant: 'number',
-    test_fn: (x => /^[ \t]*[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]\d+)?[ \t]*$/i.test( x )),
+    test_fn: (x => numberRegEx.test( x )),
     json_type: 'number',
     secondary_json_type: 'string',
   },
@@ -447,11 +456,11 @@ function initBuiltins( model ) {
       const absolute = prefix + name;
       // TODO: reconsider whether to set a type to itself - looks wrong
       const art = {
-        kind: 'type', builtin: true, name: { absolute }, type: { path: [ { id: absolute } ] },
+        kind: 'type', builtin: true, name: { absolute },
       };
-      setProp( art.type, '_artifact', art );
       if (parent)
         parent._subArtifacts[name] = art;
+      setProp( art, '_origin', '' );
       setProp( art, '_effectiveType', art );
       setProp( art, '_deps', [] );
       Object.assign( art, builtins[name] );