@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/transform/transformUtilsNew.js

@@ -12,14 +12,17 @@ const { cloneCsnNonDict, cloneCsnDictionary, getUtils } = require('../model/csnU
 const { typeParameters, isBuiltinType } = require('../compiler/builtins');
 const { ModelError } = require("../base/error");
 const { forEach } = require('../utils/objectUtils');
+const { pathName } = require("../compiler/utils");
 
+const RestrictedOperators = ['<', '>', '>=', '<='];
+const RelationalOperators = ['=', '!=', '<>', 'is' /*, 'like'*/,...RestrictedOperators];
 // Return the public functions of this module, with 'model' captured in a closure (for definitions, options etc).
 // Use 'pathDelimiter' for flattened names (e.g. of struct elements or foreign key elements).
 // 'model' is compacted new style CSN
 // TODO: Error and warnings handling with compacted CSN? - currently just throw new ModelError for everything
 // TODO: check the situation with assocs with values. In compacted CSN such elements have only "@Core.Computed": true
 function getTransformers(model, options, pathDelimiter = '_') {
-  const { error, warning, info } = makeMessageFunction(model, options);
+  const { message, error, warning, info } = makeMessageFunction(model, options);
   const csnUtils = getUtils(model);
   const {
     getCsnDef,
@@ -500,7 +503,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    * Create a 'DraftAdministrativeData' projection on entity 'DRAFT.DraftAdministrativeData'
    * in service 'service' and add it to the model.
    *
-   * For forHanaNew, use String(36) instead of UUID and UTCTimestamp instead of Timestamp
+   * For forRelationalDB, use String(36) instead of UUID and UTCTimestamp instead of Timestamp
    *
    * @param {string} service
    * @param {boolean} [hanaMode=false] Turn UUID into String(36)
@@ -709,7 +712,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       if (artifactName) {
         path = ['definitions', artifactName, 'elements', elemName];
       }
-      error(null, path, { name: elemName }, `Generated element $(NAME) conflicts with existing element`);
+      error(null, path, { name: elemName }, 'Generated element $(NAME) conflicts with existing element');
       return;
     }
 
@@ -863,9 +866,9 @@ function getTransformers(model, options, pathDelimiter = '_') {
     if (array.length > 1) {
       const loc = ['definitions', artifactName];
       if (err === true) {
-        error(null, loc, { anno: annoName }, `Annotation $(ANNO) must be assigned only once`);
+        error(null, loc, { anno: annoName }, 'Annotation $(ANNO) must be assigned only once');
       } else {
-        warning(null, loc, { anno: annoName },`Annotation $(ANNO) must be assigned only once`);
+        warning(null, loc, { anno: annoName },'Annotation $(ANNO) must be assigned only once');
       }
     }
   }
@@ -956,7 +959,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     node[name] = value;
     if(wasOverwritten)
       info(null, path, { anno: name, prop: value, otherprop: oldValue },
-      `Value $(OTHERPROP) of annotation $(ANNO) is overwritten with new value $(PROP)`);
+      'Value $(OTHERPROP) of annotation $(ANNO) is overwritten with new value $(PROP)');
     return wasOverwritten;
   }
 
@@ -1113,92 +1116,122 @@ function getTransformers(model, options, pathDelimiter = '_') {
       for(let i = 0; i < expr.length; i++)
       {
         if(Array.isArray(expr[i]))
-          rc.push(expr[i].map(expand, location));
+          rc.push(expr[i].map(e => expand(e, location)));
 
         if(i < expr.length-2)
         {
-          const [lhs, op, rhs] = expr.slice(i);
+          let [lhs, op, not, rhs] = expr.slice(i);
+          if(not !== 'not') {
+            rhs = not;
+            not = false;
+          }
+          if(lhs === undefined || op === undefined || rhs === undefined)
+            return expr;
 
           // we might have to ad-hoc resolve a ref, since handleExists is run before hand and generates new refs.
           const lhsArt = lhs._art || lhs.ref && !lhs.$scope && inspectRef(location.concat(i)).art;
           const rhsArt = rhs._art || rhs.ref && !rhs.$scope && inspectRef(location.concat(i+2)).art;
-          // lhs & rhs must be expandable types (structures or managed associations)
-          if(lhsArt && rhsArt &&
-             lhs.ref && rhs.ref &&
-             isExpandable(lhsArt) && isExpandable(rhsArt) &&
-             ['=', '<', '>', '>=', '<=', '!=', '<>'].includes(op) &&
-             !(isDollarSelfOrProjectionOperand(lhs) || isDollarSelfOrProjectionOperand(rhs))) {
+          const lhsIsVal = (lhs.val !== undefined);
+          // if ever rhs should be alowed to be a value uncomment this
+          const rhsIsVal = (rhs === 'null' /*|| rhs.val !== undefined*/);
 
+          // lhs & rhs must be expandable types (structures or managed associations)
+          // if ever lhs should be alowed to be a value uncomment this
+          if(!(lhsIsVal /*&& rhsIsVal*/) &&
+             !(isDollarSelfOrProjectionOperand(lhs) || isDollarSelfOrProjectionOperand(rhs)) &&
+             RelationalOperators.includes(op) &&
+             (lhsIsVal || (lhsArt && lhs.ref && isExpandable(lhsArt))) &&
+             (rhsIsVal || (rhsArt && rhs.ref && isExpandable(rhsArt)))
+            ) {
+
+            if(RestrictedOperators.includes(op)) {
+              message('expr-unexpected-operator', location, { op }, 'Unexpected operator $(OP) in structural comparison');
+            }
             // if path is scalar and no assoc or has no type (@Core.Computed) use original expression
             // only do the expansion on (managed) assocs and (items.)elements, array of check in ON cond is done elsewhere
-            const lhspaths = /*isScalarOrNoType(lhs._art) ? [ lhs ] : */ flattenPath({ _art: lhsArt, ref: lhs.ref }, false, true );
-            const rhspaths = /*isScalarOrNoType(rhs._art) ? [ rhs ] : */ flattenPath({ _art: rhsArt, ref: rhs.ref }, false, true );
+            const lhspaths = lhsIsVal ? [] : flattenPath({ _art: lhsArt, ref: lhs.ref }, false, true );
+            const rhspaths = rhsIsVal ? [] : flattenPath({ _art: rhsArt, ref: rhs.ref }, false, true );
 
             // mapping dict for lhs/rhs for mismatch check
             // strip lhs/rhs prefix from flattened paths to check remaining common trailing path
             // if path is idempotent, it doesn't produce new flattened paths (ends on scalar type)
             // key is then empty string on both sides '' (=> equality)
             // Path matches if lhs/rhs are available
-            const xref = lhspaths.reduce((a, v) => {
-              a[v.ref.slice(lhs.ref.length).join('.')] = { lhs: v };
-              return a;
-            }, Object.create(null));
-
-            rhspaths.forEach(v => {
-              const k = v.ref.slice(rhs.ref.length).join('.');
-              if(xref[k])
-                xref[k].rhs = v;
-              else
-                xref[k] = { rhs: v };
-            });
-
+            const xref = createXRef(lhspaths, rhspaths, lhs, rhs, lhsIsVal, rhsIsVal);
+            const xrefkeys = Object.keys(xref);
+            const xrefvalues = Object.values(xref);
             let cont = true;
-            for(const xn in xref) {
-              const x = xref[xn];
 
+            if(op === 'like' && xrefvalues.reduce((a, v) => {
+              return (v.lhs && v.rhs) ? a + 1: a;
+            }, 0) === 0) {
+              // error if intersection of paths is zero
+              error(null, location, { lhs: pathName(lhs.ref), op, rhs: pathName(rhs.ref) },
+                'Expected compatible types for $(LHS) $(OP) $(RHS)');
+              cont = false;
+            }
+
+            cont && xrefkeys.forEach(xn => {
+              const x = xref[xn];
+              const prefix = `${pathName(lhs.ref)} ${op} ${pathName(rhs.ref)}`;
               // do the paths match?
-              if(!(x.lhs && x.rhs)) {
-                if(xn.length)
-                  error(null, location, `'${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}': Sub path '${xn}' not found in ${((x.lhs ? rhs : lhs).ref.join('.'))}`)
-                else
-                  error(null, location, `'${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}': Path '${((x.lhs ? lhs : rhs).ref.join('.'))}' does not match ${((x.lhs ? rhs : lhs).ref.join('.'))}`)
+              if(op !== 'like' && !(x.lhs && x.rhs)) {
+                if(xn.length) {
+                  error(null, location, { prefix, name: xn, alias: pathName((x.lhs ? rhs : lhs).ref) },
+                    '$(PREFIX): Sub path $(NAME) not found in $(ALIAS)');
+                }
+                else {
+                  error(null, location, { prefix, name: pathName((x.lhs ? lhs : rhs).ref), alias: pathName((x.lhs ? rhs : lhs).ref) },
+                    '$(PREFIX): Path $(NAME) does not match $(ALIAS)');
+                }
                 cont = false;
               }
               // lhs && rhs are present, consistency checks that affect both ends
               else {
                 // is lhs scalar?
-                if(!isScalarOrNoType(x.lhs._art)) {
-                  error(null, location, `'${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}': Path '${x.lhs.ref.join('.')}${(xn.length ? '.' + xn : '')}' must end on a scalar type`)
+                if(!lhsIsVal && x.lhs && !isScalarOrNoType(x.lhs._art)) {
+                  error(null, location, { prefix, name: `${pathName(x.lhs.ref)}${(xn.length ? '.' + xn : '')}` },
+                    '$(PREFIX): Path $(NAME) must end on a scalar type')
                   cont = false;
                 }
                 // is rhs scalar?
-                if(!isScalarOrNoType(x.rhs._art)) {
-                  error(null, location, `'${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}': Path '${x.rhs.ref.join('.')}${(xn.length ? '.' + xn : '')}' must end on a scalar type`)
+                if(!rhsIsVal && x.rhs && !isScalarOrNoType(x.rhs._art)) {
+                  error(null, location, { prefix, name: `${pathName(x.rhs.ref)}${(xn.length ? '.' + xn : '')}` },
+                    '$(PREFIX): Path $(NAME) must end on a scalar type');
                   cont = false;
                 }
-                // info about type incompatibility if no other errors occured
-                if(xn && cont) {
+                // info about type incompatibility if no other errors occurred
+                if(!(lhsIsVal || rhsIsVal) && x.lhs && x.rhs && xn && cont) {
                   const lhst = getType(x.lhs._art);
                   const rhst = getType(x.rhs._art);
                   if(lhst !== rhst) {
-                    info(null, location, `'${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}': Types for sub path '${xn}' don't match`)
+                    info(null, location, { prefix, name: xn },'$(PREFIX): Types for sub path $(NAME) don\'t match');
                   }
                 }
               }
-            }
+            });
             // don't continue if there are path errors
             if(!cont)
               return expr;
 
-            Object.keys(xref).forEach((k, i) => {
-              const x = xref[k];
+            // if lhs and rhs are refs set operator from 'like' to '='
+            if(op === 'like' && !(lhsIsVal || rhsIsVal)) {
+              op = '=';
+            }
+            // t_0 OR ... OR t_n with t = (a <not equal> b)
+            const bop = (op === 'is' && not) || op === '!=' || op === '<>' ? 'or' : 'and';
+            rc.push('(');
+            xrefvalues.filter(x => x.lhs && x.rhs).forEach((x,i) => {
               if(i>0)
-                rc.push('and');
+                rc.push(bop);
               rc.push(x.lhs);
               rc.push(op);
+              if(not)
+                rc.push('not')
               rc.push(x.rhs);
             });
-            i += 2;
+            rc.push(')');
+            i += not ? 3 : 2;
           }
           else
             rc.push(expr[i]);
@@ -1208,6 +1241,44 @@ function getTransformers(model, options, pathDelimiter = '_') {
       }
       return rc;
 
+      function createXRef(lhspaths, rhspaths, lhs, rhs, lhsIsVal, rhsIsVal) {
+        // mapping dict for lhs/rhs for mismatch check
+        // strip lhs/rhs prefix from flattened paths to check remaining common trailing path
+        // if path is idempotent, it doesn't produce new flattened paths (ends on scalar type)
+        // key is then empty string on both sides '' (=> equality)
+        // Path matches if lhs/rhs are available
+        let xref;
+        if(!lhsIsVal) {
+          xref = lhspaths.reduce((a, v) => {
+            a[v.ref.slice(lhs.ref.length).join('.')] = rhsIsVal ? { lhs: v, rhs } : { lhs: v };
+            return a;
+          }, Object.create(null));
+
+          rhspaths.forEach(v => {
+            const k = v.ref.slice(rhs.ref.length).join('.');
+            if(xref[k])
+              xref[k].rhs = v;
+            else
+                xref[k] = { rhs: v };
+          });
+        }
+        else if(!rhsIsVal) {
+          xref = rhspaths.reduce((a, v) => {
+            a[v.ref.slice(rhs.ref.length).join('.')] = lhsIsVal ? { lhs, rhs: v } : { rhs: v };
+            return a;
+          }, Object.create(null));
+
+          lhspaths.forEach(v => {
+            const k = v.ref.slice(lhs.ref.length).join('.');
+            if(xref[k])
+              xref[k].lhs = v;
+            else
+                xref[k] = { lhs: v };
+          });
+        }
+        return xref;
+      }
+
       function getType(art) {
         const effart = effectiveType(art);
         return Object.keys(effart).length ? effart : art.type;
@@ -1218,7 +1289,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
         if(art) {
           // items in ON conds are illegal but this should be checked elsewhere
           const elements = art.elements || (art.items && art.items.elements);
-          return (elements || art.target && art.keys)
+          return !!(elements || art.target && art.keys)
         }
         return false;
       }
@@ -1241,7 +1312,6 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
 }
 
-
 /**
  * Modify the given CSN/artifact in-place, applying the given customTransformations.
  * Dictionaries are correctly handled - a "type" transformer will not be called on an entity called "type".
@@ -1333,5 +1403,6 @@ function transformModel(csn, customTransformations, transformNonEnumerableElemen
 module.exports = {
   // This function retrieves the actual exports
   getTransformers,
-  transformModel
+  transformModel,
+  RelationalOperators
 };

package/lib/transform/translateAssocsToJoins.js

@@ -9,7 +9,7 @@ const { deduplicateMessages } = require('../base/messages');
 const { timetrace } = require('../utils/timetrace');
 // Paths that start with an artifact of protected kind are special
 // either ignore them in QAT building or in path rewriting
-const internalArtifactKinds = ['builtin'/*, '$parameters'*/, 'param'];
+const internalArtifactKinds = ['builtin', '$parameters', 'param'];
 
 function translateAssocsToJoinsCSN(csn, options){
   timetrace.start('Recompiling model');
@@ -444,7 +444,7 @@ function translateAssocsToJoins(model, inputOptions = {})
         }
         else if(art.target) { // it's not an artifact, so it should be an assoc step
           if(joinTree === undefined)
-            throw Error('Cannot follow Associations without starting Entity');
+            throw Error('Can\'t follow Associations without starting Entity');
 
           if(!childQat.$QA)
             childQat.$QA = createQA(env, art.target._artifact, art.name.id, childQat._namedArgs);
@@ -762,7 +762,8 @@ function translateAssocsToJoins(model, inputOptions = {})
 
         let [head, ...tail] = path;
 
-        if(internalArtifactKinds.includes(head._artifact.kind)) // don't rewrite path
+        // don't rewrite path
+        if(internalArtifactKinds.includes(head._artifact.kind))
           return pathNode;
 
         // strip the absolute path indicators
@@ -901,29 +902,29 @@ function translateAssocsToJoins(model, inputOptions = {})
               // source side from view point of view (target side from forward point of view)
               path = tail; // pop assoc step
               let elt = env.lead._combined[path[0].id];
-              let err = 'Element "' + path[0].id +
-                '" referred in association "' + assoc.name.id +'" of Artifact "' + assoc.name.absolute +'"';
 
               if(elt) {
                 if(Array.isArray(elt)) {
-                  err += ' is available from multiple query sources ' +
-                    elt.map(e => '"' + e._origin.name.absolute + '"').join(', ');
-                  error(null, assocQAT._origin.location, `${err}`);
+                  const names = elt.map(e => e._origin.name.absolute);
+                  error(null, [ assocQAT._origin.location, assocQAT._origin ], { elemref: path[0].id, id: assoc.name.id, art: assoc.name.absolute, names },
+                    'Element $(ELEMREF) referred in association $(ID) of artifact $(ART) is available from multiple query sources $(NAMES)');
                   return pathNode.path;
                 } else {
                   // check if element has same origin on both ends
                   if(elt._origin._main !== path[0]._artifact._origin._main) {
-                    err += ' originates from "' +
-                      path[0]._artifact._origin._main.name.absolute+'" and from "' +
-                      elt._origin._main.name.absolute +
-                      '" in "' + elt._main.name.absolute + '"';
-                    warning(null, assocQAT._origin.location, `${err}`);
+                    warning(null, [ assocQAT._origin.location, assocQAT._origin ], {
+                      elemref: path[0].id,
+                      id: assoc.name.id, art: assoc.name.absolute,
+                      name: path[0]._artifact._origin._main.name.absolute,
+                      alias: elt._origin._main.name.absolute,
+                      source: elt._main.name.absolute,
+                    }, 'Element $(ELEMREF) referred in association $(ID) of artifact $(ART) originates from $(NAME) and from $(ALIAS) in $(SOURCE)');
                   }
                   _navigation = elt._parent;
                 }
               } else {
-                err += ' has not been found';
-                error(null, assocQAT._origin.location, `${err}`);
+                error(null, [ assocQAT._origin.location, assocQAT._origin ], { elemref: path[0].id, id: assoc.name.id, art: assoc.name.absolute },
+                  'Element $(ELEMREF) referred in association $(ID) of artifact $(ART) has not been found');
                 return pathNode.path;
               }
             } else {
@@ -1536,7 +1537,7 @@ function translateAssocsToJoins(model, inputOptions = {})
             (  // not leaf
               i < tail.length-1 &&
               // path terminates on a scalar type
-              // _effectiveType.elements can be removed if forHanaNew can expand fk paths correctly
+              // _effectiveType.elements can be removed if forRelationalDB can expand fk paths correctly
               !(tail[tail.length-1]._artifact._effectiveType.elements || tail[tail.length-1]._artifact._effectiveType.target) &&
               // association is managed
               art.foreignKeys &&

package/lib/utils/moduleResolve.js

@@ -173,13 +173,13 @@ function _errorFileNotFound(dep, options, { error }) {
       resolved = resolved.replace( /\\/g, '/' );
     for (const from of dep.usingFroms) {
       error( 'file-not-readable', from.location, { file: resolved },
-             'Cannot read file $(FILE)' );
+             'Can\'t read file $(FILE)' );
     }
   }
   else if (isLocalFile( dep.module ) ) {
     for (const from of dep.usingFroms) {
       error( 'file-unknown-local', from.location, { file: dep.module },
-             'Cannot find local module $(FILE)' );
+             'Can\'t find local module $(FILE)' );
     }
   }
   else {
@@ -187,8 +187,8 @@ function _errorFileNotFound(dep, options, { error }) {
     for (const from of dep.usingFroms) {
       error( 'file-unknown-package', from.location,
              { file: dep.module, '#': internal }, {
-               std: 'Cannot find package $(FILE)',
-               internal: 'Cannot find package module $(FILE)',
+               std: 'Can\'t find package $(FILE)',
+               internal: 'Can\'t find package module $(FILE)',
              } );
     }
   }
@@ -417,7 +417,7 @@ function resolveCDS(moduleName, options, callback) {
    * @returns {Error}
    */
   function makeNotFoundError() {
-    const moduleError = new Error(`Cannot find module '${ moduleName }' from '${ options.basedir }'`);
+    const moduleError = new Error(`Can't find module '${ moduleName }' from '${ options.basedir }'`);
     // eslint-disable-next-line
     moduleError['code'] = 'MODULE_NOT_FOUND';
     return moduleError;

package/lib/utils/objectUtils.js

@@ -37,7 +37,7 @@ function createDict(obj) {
  */
 function forEach(obj, callback) {
   for (const key in obj) {
-    if (Object.hasOwnProperty.call(obj, key))
+    if (Object.prototype.hasOwnProperty.call(obj, key))
       callback(key, obj[key]);
   }
 }
@@ -51,7 +51,7 @@ function forEach(obj, callback) {
  */
 function forEachValue(o, callback) {
   for (const key in o) {
-    if (Object.hasOwnProperty.call(o, key))
+    if (Object.prototype.hasOwnProperty.call(o, key))
       callback(o[key]);
   }
 }
@@ -65,7 +65,7 @@ function forEachValue(o, callback) {
  */
 function forEachKey(o, callback) {
   for (const key in o) {
-    if (Object.hasOwnProperty.call(o, key))
+    if (Object.prototype.hasOwnProperty.call(o, key))
       callback(key);
   }
 }

package/lib/utils/term.js

@@ -1,6 +1,6 @@
 //
 // This file is used for color output to stderr and stdout.
-// Use `term.error`, `term.warn` and `term.info` as they use color output
+// Use `term.asError`, `term.asWarn` and `term.asInfo` as they use color output
 // per default if the process runs in a TTY, i.e. stdout as well as
 // stderr are TTYs.  stderr/stdout are no TTYs if they are
 // (for example) piped into another process or written to file:
@@ -88,10 +88,10 @@ function term(useColor = 'auto') {
     bold,
 
     severity: asSeverity,
-    error: asError,
-    warn: asWarning,
-    info: asInfo,
-    help: asHelp,
+    asError,
+    asWarning,
+    asInfo,
+    asHelp,
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "3.1.2",
+  "version": "3.4.0",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",
@@ -16,7 +16,7 @@
   "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.11 explicitly\" && npm install --save --save-exact --no-package-lock sqlite3@5.0.11",
+    "xmakeBeforeInstall": "echo \"Due to binary mirror, use sqlite 5.1.2 explicitly\" && npm install --save --save-exact --no-package-lock sqlite3@5.1.2",
     "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 --reporter min --reporter-option maxDiffSize=0 scripts/testLazyLoading.js && mocha --parallel --reporter min --reporter-option maxDiffSize=0 test/ test3/",

package/share/messages/anno-duplicate-unrelated-layer.md

@@ -11,7 +11,7 @@ CDL file is equivalent to a layer.
 
 Erroneous code example using four CDS files:
 
-```cdl
+```cds
 // (1) Base.cds: Contains the artifact that should be annotated
 entity FooBar {  }
 
@@ -41,15 +41,15 @@ represents one layer.
 
 ## How to Fix
 
-To fix the issue, remove one of the duplicate annotations.  Chances are, that
-only one was intended to begin with.  For the erroneous example above, remove
-the annotation from (3).
+Remove one of the duplicate annotations.  Chances are, that only one was
+intended to begin with.  For the erroneous example above, remove the annotation
+from (3).
 
 Alternatively, add an annotation assignment to (4).  This annotation has
 precedence and the error will vanish.  For the example above, (4) will look
 like this:
 
-```cdl
+```cds
 // (4) All.cds: Combine all files
 using from './FooAnnotate';
 using from './BarAnnotate';
@@ -60,7 +60,7 @@ annotate FooBar with @Anno: 'Bar';
 You can also make (3) depend on (2) so that they are no longer in unrelated
 layers and the compiler can determine which annotation to apply.
 
-```cdl
+```cds
 // (3) BarAnnotate.cds: Now depends on (2)
 using from './FooAnnotate';
 annotate FooBar with @Anno: 'Bar';

package/share/messages/check-proper-type-of.md

@@ -4,13 +4,13 @@ An element in a `type of` expression doesn’t have proper type information.
 
 The message's severity is `Info` but may be raised to `Error` in the SQL,
 SAP HANA, and OData backends.  These backends require elements to have a type.
-Otherwise they aren’t able to render elements (for example, to SQL columns).
+Otherwise, they aren’t able to render elements (for example, to SQL columns).
 
 ## Example
 
 Erroneous code example:
 
-```cdl
+```cds
 entity Foo {
   key id : Integer;
 };
@@ -33,9 +33,9 @@ properties but won’t have a proper type, which is required by some backends.
 
 ## How to Fix
 
-To fix the issue, assign an explicit type to `ViewFoo:calculatedField`.
+Assign an explicit type to `ViewFoo:calculatedField`.
 
-```cdl
+```cds
 view ViewFoo as select from Foo {
   1+1 as calculatedField @(anno) : Integer
 };

package/share/messages/check-proper-type.md

@@ -27,8 +27,8 @@ Erroneous code example:
 
 ## How to Fix
 
-To fix the issue, add explicit type information to `MainType`, for example, add
-an `elements` property to make a structured type.
+Add explicit type information to `MainType`, for example, add an `elements`
+property to make a structured type.
 
 ```json
 {

package/share/messages/duplicate-autoexposed.md

@@ -15,7 +15,7 @@ adapt your model to fix the error.
 
 Erroneous code example:
 
-```cdl
+```cds
 // (1)
 entity ns.first.Foo {
   key parent : Association to one ns.Base;
@@ -46,13 +46,13 @@ of (2) and (3) are ignored, a name collision happens.
 
 ## How to Fix
 
-To fix the issue, you need to explicitly expose one or more entities under
-a name that does not exist in the service, yet.
+You need to explicitly expose one or more entities under a name that does not
+exist in the service, yet.
 
 For the erroneous example above, you could add these two lines to the service
 `ns.MyService`:
 
-```cdl
+```cds
   entity first.Foo as projection on ns.first.Foo;   // (5)
   entity second.Foo as projection on ns.second.Foo; // (6)
 ```

package/share/messages/extend-repeated-intralayer.md

@@ -11,7 +11,7 @@ They form a cyclic connection through their dependencies
 
 Erroneous code example with a single CDL file:
 
-```cdl
+```cds
 entity FooBar { }
 
 extend FooBar { foo : Integer; }
@@ -24,7 +24,7 @@ inside `FooBar` may not be stable.  You therefore can’t depend on it.
 It's also possible to trigger this warning with multiple files.
 Look at the following example:
 
-```cdl
+```cds
 // (1) Definition.cds
 using from './Extension.cds';
 entity FooBar { };
@@ -40,10 +40,9 @@ layer with multiple extensions.  Again, the element order isn’t stable.
 
 ## How to Fix
 
-To fix the issue, move extensions for the same artifact into the same extension
-block:
+Move extensions for the same artifact into the same extension block:
 
-```cdl
+```cds
 // (1) Definition.cds : No extension block
 using from './Extension.cds';
 entity FooBar { }

package/share/messages/extend-unrelated-layer.md

@@ -11,7 +11,7 @@ They form a cyclic connection through their dependencies
 
 Erroneous code example using four CDS files:
 
-```cdl
+```cds
 // (1) Base.cds: Contains the artifact that should be extended
 entity FooBar {  }
 
@@ -38,13 +38,13 @@ represents one layer.
 
 ## How to Fix
 
-To fix the issue, move extensions for the same artifact into the same layer,
-that is, the same file.
+Move extensions for the same artifact into the same layer, that is, the same
+file.
 
 For the erroneous example above, remove the extension from (3) and move
 it to (2):
 
-```cdl
+```cds
 // (2) FooExtend.cds
 using from './Base';
 extend FooBar {

package/share/messages/message-explanations.json

@@ -8,8 +8,10 @@
     "extend-repeated-intralayer",
     "extend-unrelated-layer",
     "redirected-to-ambiguous",
+    "redirected-to-complex",
     "redirected-to-unrelated",
     "rewrite-not-supported",
-    "syntax-expected-integer"
+    "syntax-expecting-integer",
+    "wildcard-excluding-one"
   ]
 }