@sap/cds-compiler 3.0.0 → 3.1.2

package/lib/transform/db/associations.js

@@ -107,12 +107,12 @@ function attachOnConditions(csn, pathDelimiter) {
  * @param {string} pathDelimiter
  * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition
  */
-function getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter) {
+function getFKAccessFinalizer(csn, pathDelimiter) {
   const {
     inspectRef,
   } = getUtils(csn);
 
-  return handleManagedAssocStepsInOnCondition;
+  return handleManagedAssocSteps;
 
   /**
    * Loop over all elements and for all unmanaged associations translate
@@ -123,45 +123,53 @@ function getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter) {
    * @param {CSN.Artifact} artifact Artifact to check
    * @param {string} artifactName Name of the artifact
    */
-  function handleManagedAssocStepsInOnCondition(artifact, artifactName) {
-    for (const elemName in artifact.elements) {
-      const elem = artifact.elements[elemName];
-      // The association is an unmanaged on
-      if (!elem.keys && elem.target && elem.on) {
-        applyTransformationsOnNonDictionary(elem, 'on', {
-          ref: (refOwner, prop, ref, path) => {
-            // [<assoc base>.]<managed assoc>.<field>
-            if (ref.length > 1) {
-              const { links } = inspectRef(path);
-              if (links) {
-                // eslint-disable-next-line for-direction
-                for (let i = links.length - 1; i >= 0; i--) {
-                  const link = links[i];
-                  // We found the latest managed assoc path step
-                  if (link.art && link.art.target && link.art.keys &&
+  function handleManagedAssocSteps(artifact, artifactName) {
+    const transformer = {
+      ref: (refOwner, prop, ref, path) => {
+        // [<assoc base>.]<managed assoc>.<field>
+        if (ref.length > 1) {
+          const { links } = inspectRef(path);
+          if (links) {
+            // eslint-disable-next-line for-direction
+            for (let i = links.length - 1; i >= 0; i--) {
+              const link = links[i];
+              // We found the latest managed assoc path step
+              if (link.art && link.art.target && link.art.keys &&
                     // Doesn't work when ref-target (filter condition) or similar is used
                     !ref.slice(i).some(refElement => typeof refElement !== 'string')) {
-                    // We join the managed assoc with everything following it
-                    const sourceElementName = ref.slice(i).join(pathDelimiter);
-                    const source = findSource(links, i - 1) || artifact;
-                    // allow specifying managed assoc on the source side
-                    const fks = link.art.keys.filter(fk => ref[i] + pathDelimiter + fk.ref[0] === sourceElementName);
-                    if (fks && fks.length >= 1) {
-                      const fk = fks[0];
-                      const managedAssocStepName = refOwner.ref[i];
-                      const fkName = `${managedAssocStepName}${pathDelimiter}${fk.as}`;
-                      if (source && source.elements[fkName])
-                        refOwner.ref = [ ...ref.slice(0, i), fkName ];
-                    }
-                  }
+                // We join the managed assoc with everything following it
+                const sourceElementName = ref.slice(i).join(pathDelimiter);
+                const source = findSource(links, i - 1) || artifact;
+                // allow specifying managed assoc on the source side
+                const fks = link.art.keys.filter(fk => ref[i] + pathDelimiter + fk.ref[0] === sourceElementName);
+                if (fks && fks.length >= 1) {
+                  const fk = fks[0];
+                  const managedAssocStepName = refOwner.ref[i];
+                  const fkName = `${managedAssocStepName}${pathDelimiter}${fk.as}`;
+                  if (source && source.elements[fkName])
+                    refOwner.ref = [ ...ref.slice(0, i), fkName ];
                 }
               }
             }
-          },
-        }, {}, [ 'definitions', artifactName, 'elements', elemName ]);
-      }
+          }
+        }
+      },
+    };
+    for (const elemName in artifact.elements) {
+      const elem = artifact.elements[elemName];
+      // The association is an unmanaged one
+      if (!elem.keys && elem.target && elem.on)
+        applyTransformationsOnNonDictionary(elem, 'on', transformer, {}, [ 'definitions', artifactName, 'elements', elemName ]);
+    }
+
+    if (artifact.query || artifact.projection) {
+      applyTransformationsOnNonDictionary(artifact, artifact.query ? 'query' : 'projection', {
+        orderBy: (parent, prop, thing, path) => applyTransformationsOnNonDictionary(parent, prop, transformer, {}, path),
+        groupBy: (parent, prop, thing, path) => applyTransformationsOnNonDictionary(parent, prop, transformer, {}, path),
+      }, {}, [ 'definitions', artifactName ]);
     }
 
+
     /**
      * Find out where the managed association is
      *
@@ -183,5 +191,5 @@ function getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter) {
 }
 module.exports = {
   attachOnConditions,
-  getManagedAssocStepsInOnConditionFinalizer,
+  getFKAccessFinalizer,
 };

package/lib/transform/db/cdsPersistence.js

@@ -78,7 +78,6 @@ function getAssocToSkippedIgnorer(csn, options, messageFunctions) {
    * @param {string} memberName
    * @param {string} prop
    * @param {CSN.Path} path
-   * @todo Why do we check for @cds.persistence.exists here if the parent-function only calls this for skip/abstract?
    */
   function ignore(member, memberName, prop, path) {
     if (options.sqlDialect === 'hana' &&

package/lib/transform/db/flattening.js

@@ -47,7 +47,6 @@ function removeLeadingSelf(csn) {
  * @param {object} iterateOptions
  */
 function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOptions = {}) {
-  const typeCache = Object.create(null); // TODO: Argument as well?
   /**
    * Remove .localized from the element and any sub-elements
    *
@@ -83,14 +82,14 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
     cast: (parent, prop, cast, path) => {
       // Resolve cast already - we otherwise lose .localized
       if (cast.type && !isBuiltinType(cast.type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(cast.type, path) && !isODataItems(cast.type)))
-        toFinalBaseType(parent.cast, resolved, true, typeCache);
+        toFinalBaseType(parent.cast, resolved, true);
     },
     // @ts-ignore
     type: (parent, prop, type, path) => {
       if (options.toOdata && parent.kind && parent.kind in ignoreOdataKinds)
         return;
       if (!isBuiltinType(type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(type, path) && !isODataItems(type))) {
-        toFinalBaseType(parent, resolved, true, typeCache);
+        toFinalBaseType(parent, resolved, true);
         // structured types might not have the child-types replaced.
         // Drill down to ensure this.
         if (parent.elements) {
@@ -99,7 +98,7 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
             const elements = stack.pop();
             for (const e of Object.values(elements)) {
               if (e.type && !isBuiltinType(e.type))
-                toFinalBaseType(e, resolved, true, typeCache);
+                toFinalBaseType(e, resolved, true);
 
               if (e.elements)
                 stack.push(e.elements);

package/lib/transform/db/transformExists.js

@@ -349,7 +349,7 @@ function handleExists(csn, options, error) {
     const newExpr = [];
     const query = walkCsnPath(csn, queryPath);
     const expr = walkCsnPath(csn, exprPath);
-    const queryBase = query.SELECT.from.ref ? (query.SELECT.from.as || query.SELECT.from.ref[0]) : null;
+    const queryBase = query.SELECT.from.ref ? (query.SELECT.from.as || query.SELECT.from.ref) : null;
     const sources = getQuerySources(query.SELECT);
 
     for (let i = 0; i < expr.length; i++) {
@@ -457,7 +457,7 @@ function handleExists(csn, options, error) {
    *
    * A valid $self-backlink is handled in translateDollarSelfToWhere.
    *
-   * For an ordinary unmanaged association, we do the the following for each part of the on-condition:
+   * For an ordinary unmanaged association, we do the following for each part of the on-condition:
    * - target side: We prefix the real target and cut off the assoc-name from the ref
    * - source side w/ leading $self: We remove the $self and add the source side entity/query source
    * - source side w/o leading $self: We simply add the source side entity/query source in front of the ref
@@ -730,15 +730,17 @@ function handleExists(csn, options, error) {
   /**
    * Get the name of the source-side query source
    *
-   * @param {string|null} queryBase
+   * @param {string | Array | null} queryBase
    * @param {boolean} isPrefixedWithTableAlias
    * @param {CSN.Column} current
    * @param {CSN.Path} path
    * @returns {string}
    */
   function getBase(queryBase, isPrefixedWithTableAlias, current, path) {
-    if (queryBase)
-      return getRealName(csn, queryBase);
+    if (typeof queryBase === 'string') // alias
+      return queryBase;
+    else if (queryBase) // ref
+      return queryBase.length > 1 ? queryBase[queryBase.length - 1] : getRealName(csn, queryBase[0]);
     else if (isPrefixedWithTableAlias)
       return current.ref[0];
     return getParent(current, path);

package/lib/transform/draft/db.js

@@ -19,7 +19,7 @@ const booleanBuiltin = 'cds.Boolean';
  * @param {object} messageFunctions
  */
 function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
-  const draftSuffix = isDeprecatedEnabled(options, '_generatedEntityNameWithUnderscore') ? '_drafts' : '.drafts';
+  const draftSuffix = '.drafts';
   // All services of the model - needed for drafts
   const allServices = getServiceNames(csn);
   const draftRoots = new WeakMap();

package/lib/transform/forHanaNew.js

@@ -265,10 +265,10 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // To be done after handleAssociations, since then the foreign keys of the managed assocs
   // are part of the elements
   if (doA2J)
-    forEachDefinition(csn, associations.getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter));
+    forEachDefinition(csn, associations.getFKAccessFinalizer(csn, pathDelimiter));
 
   // Create convenience views for localized entities/views.
-  // To be done after getManagedAssocStepsInOnConditionFinalizer because associations are
+  // To be done after getFKAccessFinalizer because associations are
   // handled and before handleDBChecks which removes the localized attribute.
   // Association elements of localized convenience views do not have hidden properties
   // like $managed set, so we cannot do this earlier on.
@@ -392,6 +392,15 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
             setProp(SET, 'elements', query.SELECT.elements);
         }
       }
+    },
+
+  }
+
+  if(options.sqlDialect === 'postgres') {
+    killers.length = (parent) => {
+      if (parent.type === 'cds.Binary' || parent.type === 'cds.hana.BINARY') {
+        delete parent.length;
+      }
     }
   }
 

package/lib/transform/forOdataNew.js

@@ -120,7 +120,7 @@ function transform4odataWithCsn(inputModel, options) {
     return keepLocalizedViews && !isExternalServiceMember(undefined, parent);
   }
 
-  addLocalizationViews(csn, options, acceptLocalizedView);
+  addLocalizationViews(csn, options, { acceptLocalizedView, ignoreUnknownExtensions: true });
 
   const cleanup = validate.forOdata(csn, {
     message, error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, isAspect, isExternalServiceMember
@@ -178,7 +178,7 @@ function transform4odataWithCsn(inputModel, options) {
   // To be done after handleManagedAssociationsAndCreateForeignKeys,
   // since then the foreign keys of the managed assocs are part of the elements
   if(!structuredOData)
-    forEachDefinition(csn, associations.getManagedAssocStepsInOnConditionFinalizer(csn, '_'));
+    forEachDefinition(csn, associations.getFKAccessFinalizer(csn, '_'));
 
   // structure flattener reports errors, further processing is not safe -> throw exception in case of errors
   throwWithAnyError();
@@ -324,7 +324,7 @@ function transform4odataWithCsn(inputModel, options) {
       // but '@Core.Immutable' for everything else.
       if (!(node['@readonly'] && node['@insertonly'])) {
         if (name === '@readonly' && node[name] !== null) {
-          if (node.kind === 'entity') {
+          if (node.kind === 'entity' || node.kind === 'aspect') {
             setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
             setAnnotation(node, '@Capabilities.InsertRestrictions.Insertable', false);
             setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);
@@ -334,7 +334,7 @@ function transform4odataWithCsn(inputModel, options) {
         }
         // @insertonly is effective on entities/queries only
         else if (name === '@insertonly' && node[name] !== null) {
-          if (node.kind === 'entity') {
+          if (node.kind === 'entity' || node.kind === 'aspect') {
             setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
             setAnnotation(node, '@Capabilities.ReadRestrictions.Readable', false);
             setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);

package/lib/transform/localized.js

@@ -69,10 +69,9 @@ const _targetFor = Symbol('_targetFor');
  * @param {CSN.Options} options
  * @param {boolean} useJoins If true, rewrite the "localized" association to a
  *                           join in direct convenience views.
- * @param {acceptLocalizedView} [acceptLocalizedView] optional callback function returning true if the localized view
- *                                                    name and its parent name provided as parameter should be created
+ * @param {object} config
  */
-function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = null) {
+function _addLocalizationViews(csn, options, useJoins, config) {
   // Don't try to create convenience views with errors.
   if (hasErrors(options.messages))
     return csn;
@@ -81,6 +80,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
   if (hasExistingLocalizationViews(csn, options, messageFunctions))
     return csn;
 
+  const { acceptLocalizedView, ignoreUnknownExtensions } = config;
   const noCoalesce = (options.localizedLanguageFallback === 'none' ||
                       options.localizedWithoutCoalesce);
 
@@ -91,8 +91,12 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
 
   // In case that the user tried to annotate `localized.*` artifacts, apply them.
   applyAnnotationsFromExtensions(csn, {
-    overwrite: true,
-    filter: (name) => name.startsWith('localized.')
+    override: true,
+    filter: (name) => name.startsWith('localized.'),
+    notFound(name, index) {
+      if (!ignoreUnknownExtensions)
+        messageFunctions.message('anno-undefined-art', [ 'extensions', index ], { name })
+    },
   });
 
   sortCsnDefinitionsForTests(csn, options);
@@ -608,10 +612,10 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
- * @param [acceptLocalizedView] optional callback function returning true if the localized view name and its parent name provided as parameter should be created
+ * @param [config] config.acceptLocalizedView: optional callback function returning true if the localized view name and its parent name provided as parameter should be created
  */
-function addLocalizationViews(csn, options, acceptLocalizedView = null) {
-  return _addLocalizationViews(csn, options, false, acceptLocalizedView);
+function addLocalizationViews(csn, options, config = {}) {
+  return _addLocalizationViews(csn, options, false, config);
 }
 
 /**
@@ -621,10 +625,10 @@ function addLocalizationViews(csn, options, acceptLocalizedView = null) {
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
- * @param [acceptLocalizedView] optional callback function returning true if the localized view name and its parent name provided as parameter should be created
+ * @param [config] config.acceptLocalizedView: optional callback function returning true if the localized view name and its parent name provided as parameter should be created
  */
-function addLocalizationViewsWithJoins(csn, options, acceptLocalizedView = null) {
-  return _addLocalizationViews(csn, options, true, acceptLocalizedView);
+function addLocalizationViewsWithJoins(csn, options, config = {}) {
+  return _addLocalizationViews(csn, options, true, config);
 }
 
 /**

package/lib/transform/odata/typesExposure.js

@@ -10,6 +10,7 @@ const { setProp } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
 const { cloneCsnNonDict, isBuiltinType, forEachDefinition, forEachMember } = require('../../model/csnUtils');
 const { copyAnnotations } = require('../../model/csnUtils');
+const { isBetaEnabled } = require('../../base/model.js');
 
 function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackSchemaName, options, csnUtils, message) {
   const { error } = message;
@@ -92,11 +93,16 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
               : getAnonymousTypeNameInMultiSchema(newTypeName, parentName || defName))
           : `${serviceName}.${newTypeName}`;
 
-      // as soon as we leave of the anonymous world,
-      // we're no longer in a key def => don't set notNull:true on named types
-      if (!isAnonymous && isKey)
-        isKey = false;
-
+      if (!isAnonymous) {
+        // as soon as we leave of the anonymous world,
+        // we're no longer in a key def => don't set notNull:true on named types
+        if(isKey)
+          isKey = false;
+        // in case this was a named type and if the openess does not match the type definition
+        // expose the type as a new one not changing the original definition.
+        if((!!node['@open'] !== !!typeDef['@open']) && isBetaEnabled(options, 'odataOpenType'))
+          fullQualifiedNewTypeName += node['@open'] ? '_open' : '_closed';
+      }
       // check if that type is already defined
       let newType = csn.definitions[fullQualifiedNewTypeName];
       if (newType) {
@@ -111,6 +117,9 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
          * Treat items.elements as ordinary elements for now.
          */
         newType = createNewStructType(elements);
+        // if using node enforces open/closed, set it on type
+        if(node['@open'] !== undefined)
+          newType['@open'] = node['@open']
         if (node.$location)
           setProp(newType, '$location', node.$location);
 

package/lib/utils/file.js

@@ -113,11 +113,16 @@ function cdsFs(fileCache, enableTrace) {
         traceFS( 'READFILE:start:', filename );
         // TODO: set cache directly to some "delay" - store error differently?
         // e.g. an error of callback functions!
-        reader(filename, enc, ( err, data ) => {
-          fileCache[filename] = err || data;
-          traceFS( 'READFILE:data:', filename, err || data );
-          cb( err, data );
-        });
+        try {
+          reader(filename, enc, (err, data) => {
+            fileCache[filename] = err || data;
+            traceFS('READFILE:data:', filename, err || data);
+            cb(err, data);
+          });
+        }
+        catch (err) {
+          cb(err); // if filename is not a valid (e.g. contains NUL byte), readFile() may throw
+        }
       }
     };
   }
@@ -143,19 +148,24 @@ function cdsFs(fileCache, enableTrace) {
         // in the future (if we do module resolve ourself with just readFile),
         // we avoid parallel readFile by storing having an array of `cb`s in
         // fileCache[ filename ] before starting fs.readFile().
-        fsStat( filename, ( err, stat ) => {
-          if (err)
-            body = (err.code === 'ENOENT' || err.code === 'ENOTDIR') ? false : err;
-          else
-            body = !!(stat.isFile() || stat.isFIFO());
-          if (fileCache[filename] === undefined) // parallel readFile() has been processed
-            fileCache[filename] = body;
-          traceFS( 'ISFILE:data:', filename, body );
-          if (body instanceof Error)
-            cb( err );
-          else
-            cb( null, body );
-        });
+        try {
+          fsStat(filename, (err, stat) => {
+            if (err)
+              body = (err.code === 'ENOENT' || err.code === 'ENOTDIR') ? false : err;
+            else
+              body = !!(stat.isFile() || stat.isFIFO());
+            if (fileCache[filename] === undefined) // parallel readFile() has been processed
+              fileCache[filename] = body;
+            traceFS('ISFILE:data:', filename, body);
+            if (body instanceof Error)
+              cb(err);
+            else
+              cb(null, body);
+          });
+        }
+        catch (err) {
+          cb(err); // if filename is not a valid (e.g. contains NUL byte), fsStat() may throw
+        }
       }
     };
   }

package/lib/utils/moduleResolve.js

@@ -25,7 +25,6 @@ const extensions = [ '.cds', '.csn', '.json' ];
  * @todo Re-think:
  *   - Why can't a JAVA installation set a (symbolic) link?
  *   - Preferred to a local installation? Not the node-way!
- *   - Why a global?  The Umbrella could pass it as an option.
  *
  * @param {string} modulePath
  * @param {CSN.Options} options

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "3.0.0",
+  "version": "3.1.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",
@@ -16,12 +16,11 @@
   "scripts": {
     "download": "node scripts/downloadANTLR.js",
     "gen": "node ./scripts/build.js && node scripts/genGrammarChecksum.js",
-    "xmakeBeforeInstall": "echo \"Due to binary mirror, use sqlite 5.0.8 explicitly\" && npm install --save --save-exact --no-package-lock sqlite3@5.0.8",
+    "xmakeBeforeInstall": "echo \"Due to binary mirror, use sqlite 5.0.11 explicitly\" && npm install --save --save-exact --no-package-lock sqlite3@5.0.11",
     "xmakeAfterInstall": "npm run gen",
     "xmakePrepareRelease": "echo \"$(node scripts/stripReadme.js README.md)\" > README.md && node scripts/assertSnapshotVersioning.js && node scripts/assertChangelog.js && node scripts/cleanup.js --remove-dev",
-    "test": "node scripts/verifyGrammarChecksum.js && mocha --parallel --reporter min --reporter-option maxDiffSize=0 test/ test3/ && mocha scripts/testLazyLoading.js",
+    "test": "node scripts/verifyGrammarChecksum.js && mocha --reporter min --reporter-option maxDiffSize=0 scripts/testLazyLoading.js && mocha --parallel --reporter min --reporter-option maxDiffSize=0 test/ test3/",
     "testverbose": "node scripts/verifyGrammarChecksum.js && mocha --parallel test/ test3/",
-    "testdot": "node scripts/verifyGrammarChecksum.js && mocha --parallel --reporter dot --reporter-option maxDiffSize=0 --full-trace scripts/linter/lintMessages.js test/ test3/",
     "test3": "node scripts/verifyGrammarChecksum.js && node scripts/linter/lintTests.js test3/ && mocha --reporter-option maxDiffSize=0 scripts/linter/lintMessages.js test3/",
     "deployTest3SQL": "deployRefs=true mocha --reporter-option maxDiffSize=0 test3/testHANASQLDeployment.js",
     "deployTest3": "deployRefs=true mocha --reporter-option maxDiffSize=0 test3/testDeployment.js",

package/share/messages/syntax-expected-integer.md

@@ -1,12 +1,12 @@
 # syntax-expected-integer
 
 The compiler expects a safe integer here.
-The last safe Integer is `2^53 - 1` or `9007199254740991`.
+The last safe integer is `2^53 - 1` or `9007199254740991`.
 
-A safe integer is an integer that
+A safe integer is an integer that fulfills all of the following:
 
-- can be exactly represented as an IEEE-754 double precision number, and
-- whose IEEE-754 representation cannot be the result of rounding any
+- Can be exactly represented as an IEEE-754 double precision number.
+- The IEEE-754 representation cannot be the result of rounding any
   other integer to fit the IEEE-754 representation.
 
 The message's severity is `Error`.
@@ -15,13 +15,14 @@ The message's severity is `Error`.
 
 Erroneous code example:
 
+<!-- cds-mode: ignore -->
 ```cdl
 type LengthIsUnsafe : String(9007199254740992);
 type NotAnInteger : String(42.1);
 ```
 
-In the above example, the string length for the type `LengthIsUnsafe` is not a
-safe Integer. It is too large.
+In the erroneous example, the string length for the type `LengthIsUnsafe` is
+not a safe integer. It is too large.
 Likewise, the string length for the type `NotAnInteger` is a decimal.
 
 ## How to Fix
@@ -33,5 +34,5 @@ type LengthIsSafe : String(9007199254740991);
 type AnInteger : String(42);
 ```
 
-If not feasible, a string representation of the number needs to be used,
-e.g. in annotation values.
+If it's not feasible to use a safe integer, a string representation of the
+number needs to be used, for example, in annotation values.

package/lib/checks/unknownMagic.js

@@ -1,41 +0,0 @@
-'use strict';
-
-const { getVariableReplacement } = require('../model/csnUtils');
-
-// We only care about the "wild" ones - $at is validated by the compiler
-const magicVariables = {
-  $user: [
-    'id',     // $user.id
-    'locale', // $user.locale
-  ],
-  $session: [
-    // no valid ways for this
-  ],
-};
-
-/**
- * Check that the given ref does not use magic variables for which we don't have
- * a valid way of rendering.
- *
- * Valid ways:
- * - We know what to do -> $user.id on HANA
- * - The user tells us what to do -> options.variableReplacements
- *
- * @param {object} parent Object with the ref as a property
- * @param {string} name Name of the ref property on parent
- * @param {Array} ref to check
- */
-function unknownMagicVariable(parent, name, ref) {
-  if (parent.$scope && parent.$scope === '$magic') {
-    const [ head, ...rest ] = ref;
-    const tail = rest.join('.');
-    const magicVariable = magicVariables[head];
-    if (magicVariable && magicVariable.indexOf(tail) === -1 &&
-          getVariableReplacement(ref, this.options) === null)
-      this.error('ref-missing-replacement', parent.$location, { elemref: parent }, 'Missing replacement for variable $(ELEMREF)');
-  }
-}
-
-module.exports = {
-  ref: unknownMagicVariable,
-};