@sap/cds-compiler 5.1.0 → 5.2.0

package/lib/parsers/Lexer.js

@@ -0,0 +1,239 @@
+// Lexer for CDL grammar
+
+// The lexer only cares about potential keywords, not the exact list.  That is, it
+// sets the `keyword` property for all non-delimited `Id` tokens.
+
+// General remarks about regular expressions in node.js (or in general):
+//
+// - Alternatives in regexps are searched left to right, not longest as in scanner
+//   generator!
+// - Beware if a regular expression fails (or matches just one char) after having
+//   tested k characters in an input.  A regexp having a non-optional match or
+//   assertion after a loop (Kleene star) could lead to lexer execution time of
+//   O(n*n).  Therefore, regexps for strings etc only cover the opening delimiter.
+
+'use strict';
+
+const { Location } = require('../base/location'); // TODO main: add tokenIndex
+
+const rules = [                     // must not contain capturing groups!
+  { type: comment, re: '/[*/]' },
+  // token type = token text (`type: null`):
+  { type: null, re: '[-+*?()\\[\\]{},;:/@#]|\\.(?:\\.\\.?)?|<[=>]?|>=?|=>?|!=|\\|\\|' },
+  { type: ident, re: '[$_\\p{ID_Start}][$\\p{ID_Continue}\u200C\u200D]*|!\\[|"' },
+  { type: string, re: '[\'"]|`(?:``)?' }, // strings, template literal without …${}
+  { type: 'Number', re: '\\d+(?:\\.\\d+)?(?:e[-+]?\\d+)?' },
+  { type: 'IllegalToken', re: '\\S' }, // must be last
+];
+
+const rulesRegexp = new RegExp( `(${ rules.map( r => r.re ).join( ')|(' ) })`, 'iugm' );
+if (rulesRegexp.exec( '§' )[rules.length] !== '§')
+  throw Error( 'Invalid capturing group in rules regexp' );
+const newlineRegexp = /\n/g;       // TODO: \r?, PS, LS
+
+const commentRegexps = { '//': /$/gm, '/*': /\*\//g };
+const stringRegexps = { "'": /'|$/gm, '`': /[`\\]/g, '```': /```|\\/g };
+const identRegexps = { '![': /\]|$/gm, '"': /"|$/gm };
+
+const quotedLiterals = [ 'date', 'time', 'timestamp', 'x' ];
+
+class Token {
+  type;
+  text;
+  keyword;
+  location;
+  parsed;
+  get isIdentifier() {          // compatibility method
+    return this.parsed !== 'keyword' && this.parsed !== 'token' && this.parsed;
+  }
+  get tokenIndex() {
+    return this.location.tokenIndex;
+  }
+}
+
+class Lexer {
+  constructor( file, input ) {
+    this.file = file;
+    this.input = input;       // string
+    this.linePositions = undefined;
+    this.location = undefined;
+  }
+
+  characterPos( line, col ) {
+    return this.linePositions[line - 1] + col - 1;
+  }
+
+  tokenize( parser ) {
+    this.linePositions = [ 0 ];
+    parser.tokens = [];
+    parser.docComments = [];
+    newlineRegexp.lastIndex = 0;
+    while (newlineRegexp.test( this.input ))
+      this.linePositions.push( newlineRegexp.lastIndex );
+
+    const { file } = this;
+    let line = 1;
+    rulesRegexp.lastIndex = 0;
+    let match;
+    // eslint-disable-next-line no-cond-assign
+    while (match = rulesRegexp.exec( this.input )) {
+      let text = match[0];
+      const group = match.indexOf( text, 1 ) - 1;
+      let type = rules[group].type || text;
+      const pos = match.index;
+      while (pos >= this.linePositions[line])
+        ++line;
+      const col = pos - this.linePositions[line - 1] + 1;
+      this.location = {
+        __proto__: Location.prototype,
+        file,
+        line,
+        col,
+        endLine: line,
+        endCol: col + text.length,
+        // remark: end positions of multi-line tokens must be set by function
+        tokenIndex: parser.tokens.length,
+      };
+      let keyword;
+      if (typeof type !== 'function' ||
+          ([ type, text, keyword ] = type( text, this, parser, pos )) && type) {
+        parser.tokens.push( {
+          __proto__: Token.prototype,
+          type,
+          text,
+          keyword,
+          location: this.location,
+          parsed: undefined,
+        } );
+      }
+    }
+    line = this.linePositions.length;
+    const endCol = this.input.length - this.linePositions[line - 1] + 1;
+    const location = {
+      __proto__: Location.prototype,
+      file,
+      line,
+      col: endCol,
+      endLine: line,
+      endCol,
+      tokenIndex: parser.tokens.length,
+    };
+    parser.tokens.push( {
+      __proto__: Token.prototype,
+      type: 'EOF',
+      text: '',
+      keyword: false,
+      location,
+      parsed: undefined,
+    } );
+  }
+}
+
+function comment( text, lexer, parser, beg ) {
+  const re = commentRegexps[text];
+  re.lastIndex = rulesRegexp.lastIndex;
+  if (!re.test( lexer.input )) {
+    // eslint-disable-next-line cds-compiler/message-texts
+    parser.error( 'syntax-missing-token-end', lexer.location,
+                  { '#': 'comment', code: '/*', newCode: '*/' }, {
+                    comment: 'Comments starting with $(CODE) must end with $(NEWCODE)',
+                  } );
+  }
+  else if (text === '/*' && lexer.input.charAt( rulesRegexp.lastIndex ) === '*' &&
+           rulesRegexp.lastIndex + 2 < re.lastIndex) { // not just `/**/`
+    lexer.location.tokenIndex = parser.docComments.length;
+    parser.docComments.push( {
+      __proto__: Token.prototype,
+      type: 'DocComment',
+      text: lexer.input.substring( beg, re.lastIndex ),
+      keyword: false,
+      location: lexer.location,
+      parsed: undefined,
+    } );
+    adaptEndLocation( lexer, re.lastIndex ); // also works after push ?
+  }
+  rulesRegexp.lastIndex = re.lastIndex || lexer.input.length;
+  return [];
+}
+
+function string( text, lexer, parser, beg ) {
+  let prefix = null;
+  const re = stringRegexps[text];
+  re.lastIndex = rulesRegexp.lastIndex;
+  let esc = 0;
+  if (text !== "'") {           // single or triple back-quote
+    while (re.test( lexer.input ) && lexer.input[re.lastIndex - 1] === '\\')
+      esc = ++re.lastIndex;
+  }
+  else {                        // try with previous date/time/timestamp/x
+    prefix = parser.tokens[parser.tokens.length - 1];
+    if (prefix.location.endLine !== lexer.location.line ||
+        prefix.location.endCol !== lexer.location.col ||
+        !quotedLiterals.includes( prefix.keyword ))
+      prefix = null;
+    while (re.test( lexer.input ) && lexer.input[re.lastIndex] === "'")
+      esc = ++re.lastIndex;
+  }
+
+  let keyword;
+  const { lastIndex } = re;
+  if (!lastIndex ||             // reached EOF with template literal
+      lexer.input[lastIndex - 1] !== lexer.input[beg] || esc === lastIndex) {
+    const before = (lastIndex) ? 'string' : 'multi';
+    // eslint-disable-next-line cds-compiler/message-texts
+    parser.error( 'syntax-missing-token-end', lexer.location,
+                  { '#': before, newCode: text }, {
+                    string: 'The string literal must end with $(NEWCODE) before the end of line',
+                    multi: 'The multi-line string literal must end with $(NEWCODE)',
+                  } );
+    keyword = 0;
+    // TODO: set parsed to 0 → no further error if string is not expected?
+    prefix = null;           // no combination with date/time/…
+  }
+  adaptEndLocation( lexer, (rulesRegexp.lastIndex = lastIndex || lexer.input.length) );
+
+  if (!prefix)
+    return [ 'String', lexer.input.substring( beg, rulesRegexp.lastIndex ), keyword ];
+  prefix.type = 'QuotedLiteral';
+  prefix.text += lexer.input.substring( beg, rulesRegexp.lastIndex );
+  prefix.keyword = undefined;
+  prefix.location.endLine = lexer.location.endLine;
+  prefix.location.endCol = lexer.location.endCol;
+  return [];
+}
+
+function ident( text, lexer, parser, beg ) {
+  if (!Object.hasOwn( identRegexps, text ))
+    return [ 'Id', text, text.toLowerCase() ];
+  const re = identRegexps[text];
+  const close = (text === '"') ? '"' : ']';
+  re.lastIndex = rulesRegexp.lastIndex;
+  let esc = 0;
+  while (re.test( lexer.input ) && lexer.input[re.lastIndex] === close)
+    esc = ++re.lastIndex;
+
+  let keyword;
+  const { lastIndex } = re;
+  if (lexer.input[lastIndex - 1] !== close || esc === lastIndex) {
+    // eslint-disable-next-line cds-compiler/message-texts
+    parser.error( 'syntax-missing-token-end', lexer.location,
+                  { '#': 'ident', newcode: close }, {
+                    ident: 'The delimited id must end with $(NEWCODE) before the end of line',
+                  } );
+    keyword = 0;
+    // TODO: set parsed to 0 → no further error if string is not expected?
+  }
+  adaptEndLocation( lexer, (rulesRegexp.lastIndex = lastIndex || lexer.input.length) );
+  return [ 'Id', lexer.input.substring( beg, rulesRegexp.lastIndex ), keyword ];
+}
+
+function adaptEndLocation( lexer, pos ) {
+  let { line } = lexer.location;
+  while (pos >= lexer.linePositions[line])
+    ++line;
+  lexer.location.endLine = line;
+  lexer.location.endCol = pos - lexer.linePositions[line - 1] + 1;
+}
+
+Lexer.Token = Token;
+module.exports = Lexer;

package/lib/render/toCdl.js

@@ -320,19 +320,12 @@ function csnToCdl( csn, options, msg ) {
       result += renderAnnotateParamsInParentheses(ext, env);
 
     // Element extensions and annotations (possibly nested)
-    if (ext.elements) {
-      env.path.push('elements');
-      result += ` ${renderAnnotateStatementElements(ext.elements, env)}`;
-      env.path.length -= 1;
-    }
-    else if (ext.enum) {
-      env.path.push('enum');
-      result += ` ${renderAnnotateStatementElements(ext.enum, env)}`;
-      env.path.length -= 1;
-    }
-    else if (ext.returns) {
+    if (ext.elements || ext.enum)
+      result += ` ${renderAnnotateStatementElements(ext, env)}`;
+
+    else if (ext.returns)
       result += renderAnnotateReturns(ext, env);
-    }
+
 
     if (ext.actions) { // Bound action annotations
       result += ' actions {\n';
@@ -362,17 +355,18 @@ function csnToCdl( csn, options, msg ) {
 
   /**
    * Render the elements-specific part of an 'annotate' statement for an element dictionary
-   * 'elements' (assuming that the surrounding parent has just been rendered, without trailing newline).
+   * 'ext.elements' (assuming that the surrounding parent has just been rendered, without trailing newline).
    * Returns the resulting source string, ending without a trailing newline.
    *
-   * @param {object} elements
+   * @param {object} ext
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAnnotateStatementElements( elements, env ) {
+  function renderAnnotateStatementElements( ext, env ) {
+    const elements = ext.enum ? ext.enum : ext.elements;
     let result = '{\n';
     env.increaseIndent();
-    env.path.push('');
+    env.path.push(ext.enum ? 'enum' : 'elements', '');
     for (const name in elements) {
       env.path[env.path.length - 1] = name;
       const elem = elements[name];
@@ -380,18 +374,18 @@ function csnToCdl( csn, options, msg ) {
       result += env.indent + quoteNonIdentifierOrKeyword(name, env);
       if (elem.elements) {
         env.path.push('elements');
-        result += ` ${renderAnnotateStatementElements(elem.elements, env)}`;
+        result += ` ${renderAnnotateStatementElements(elem, env)}`;
         env.path.pop();
       }
       else if (elem.enum) {
         env.path.push('enum');
-        result += ` ${renderAnnotateStatementElements(elem.enum, env)}`;
+        result += ` ${renderAnnotateStatementElements(elem, env)}`;
         env.path.pop();
       }
 
       result += ';\n';
     }
-    env.path.length -= 1;
+    env.path.length -= 2;
     env.decreaseIndent();
     result += `${env.indent}}`;
     return result;
@@ -416,7 +410,7 @@ function csnToCdl( csn, options, msg ) {
     if (ext.returns.elements) {
       // Annotations are on separate lines: Have it aligned nicely
       result += returnAnnos ? `${env.indent}` : ' ';
-      result += renderAnnotateStatementElements(ext.returns.elements, env);
+      result += renderAnnotateStatementElements(ext.returns, env);
     }
     return result;
   }
@@ -424,18 +418,20 @@ function csnToCdl( csn, options, msg ) {
   /**
    * Render a parameter list for `annotate` statements, in parentheses `()`.
    *
-   * @param {CSN.Artifact} art
+   * @param {CSN.Artifact} ext
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAnnotateParamsInParentheses( art, env ) {
+  function renderAnnotateParamsInParentheses( ext, env ) {
     const childEnv = env.withIncreasedIndent();
     let result = '(\n';
     const paramAnnotations = [];
-    forEach(art.params, (paramName, param) => {
+    forEach(ext.params, (paramName, param) => {
       const annos = renderAnnotationAssignmentsAndDocComment(param, childEnv);
-      const name = quoteNonIdentifierOrKeyword(paramName, env.withSubPath([ 'params', paramName ]));
-      paramAnnotations.push( annos + childEnv.indent + name );
+      const name = quoteNonIdentifierOrKeyword(paramName, childEnv);
+      // Not supported, yet (#13052)
+      // const sub = (param.elements || param.enum) ? ` ${renderAnnotateStatementElements(param, childEnv)}` : '';
+      paramAnnotations.push( annos + childEnv.indent + name);
     });
     result += `${paramAnnotations.join(',\n')}\n${env.indent})`;
     return result;
@@ -686,7 +682,7 @@ function csnToCdl( csn, options, msg ) {
     let obj = annotate;
     for (let i = 2; i < env.path.length; ++i) {
       const key = env.path[i];
-      if (key === 'elements' || key === 'actions') {
+      if (key === 'elements' || key === 'actions' || key === 'params') {
         obj[key] = Object.create(null);
         const elem = env.path[i + 1];
         obj[key][elem] = {};
@@ -1251,7 +1247,7 @@ function csnToCdl( csn, options, msg ) {
    */
   function renderParameters( art, env ) {
     const childEnv = env.withIncreasedIndent();
-    const parameters = Object.keys(art.params || {}).map(name => renderParameter(name, art.params[name], childEnv.withSubPath([ 'params', name ])));
+    const parameters = Object.keys(art.params || {}).map(name => renderParameter(name, art.params[name], childEnv));
     if (parameters.length === 0)
       return '()';
     return `(\n${parameters.join(',\n')}\n${env.indent})`;

package/lib/render/toSql.js

@@ -415,7 +415,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     const tableName = renderArtifactName(artifactName);
     deletionsDuplicateChecker.addArtifact(tableName, art.$location, artifactName);
 
-    addDeletion(resultObj, artifactName, `DROP TABLE ${tableName}`);
+    addDeletion(resultObj, artifactName, `-- [WARNING] this statement is lossy\nDROP TABLE ${tableName}`);
   }
 
   // Render an artifact migration into the appropriate dictionary of 'resultObj'.
@@ -484,7 +484,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
 
         // Remove columns.
         if (removeCols.length)
-          addMigration(resultObj, artifactName, true, render.dropColumns(artifactName, removeCols));
+          addMigration(resultObj, artifactName, true, render.dropColumns(artifactName, removeCols).map(s => (options.src !== 'hdi' ? `-- [WARNING] this statement is lossy\n${s}` : s)));
 
         // Remove associations.
         removeAssocs.forEach(assoc => addMigration(resultObj, artifactName, true, render.dropAssociation(artifactName, assoc)));
@@ -550,7 +550,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
           }
         }
 
-        if (options.sqlChangeMode === 'drop' || def.old.target || def.new.target || reducesTypeSize(def)) {
+        if (options.sqlChangeMode === 'drop' || def.old.target || def.new.target || (reducesTypeSize(def) && options.src === 'hdi')) {
           // Lossy change because either an association is removed and/or added, or the type size is reduced.
           // Drop old element and re-add it in its new shape.
           const drop = def.old.target
@@ -559,10 +559,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
           const add = def.new.target
             ? render.addAssociations(artifactName, { [eltName]: def.new }, env)
             : render.addColumnsFromElementsObj(artifactName, { [eltName]: def.new }, env);
-          addMigration(resultObj, artifactName, true, render.concat(...drop, ...add));
+          addMigration(resultObj, artifactName, true, render.concat(...drop, ...add).map(s => (def.lossy && options.src !== 'hdi' ? `-- [WARNING] this statement could be lossy\n${s}` : s)));
         }
         else { // Lossless change: no associations directly affected, no size reduction.
-          addMigration(resultObj, artifactName, false, render.alterColumns(artifactName, sqlId, def, eltStrNew, eltName, activateAlterMode(env, 'migration')));
+          addMigration(resultObj, artifactName, false, render.alterColumns(artifactName, sqlId, def, eltStrNew, eltName, activateAlterMode(env, 'migration')).map(s => (def.lossy ? `-- [WARNING] this statement could be lossy\n${s}` : s)));
         }
       }
     }

package/lib/transform/db/applyTransformations.js

@@ -306,45 +306,82 @@ function applyTransformationsOnDictionary( dictionary, customTransformers = {},
  * used primarily to transform annotation expressions.
  * If propName is undefined, all properties of parent are transformed.
  * @param {object} parent Start node
- * @param {string} propName Start at specific property of parent
+ * @param {string|number} parentName Start at specific property of parent
  * @param {object} transformers Map of callback functions
  * @param {CSN.Path} path Path to parent
+ * @param {object} ctx bucket to tunnel various info into the transformers
  * @returns {object} transformed node
  */
-function transformExpression( parent, propName, transformers, path = [] ) {
-  const callT = (t, cpn, child) => {
-    const ct = t[cpn];
+function transformExpression( parent, parentName, transformers, path = [], ctx = undefined ) {
+  const callT = (t, childName, child) => {
+    const ct = t[childName];
     if (ct) {
-      const ppn = propName;
       if (Array.isArray(ct))
-        ct.forEach(cti => cti(child, cpn, child[cpn], path, parent, ppn));
+        ct.forEach(cti => cti(child, childName, child[childName], path, parent, parentName, ctx));
       else
-        ct(child, cpn, child[cpn], path, parent, ppn);
+        ct(child, childName, child[childName], path, parent, parentName, ctx);
     }
   };
+  if (parentName != null) {
+    const child = parent[parentName];
+    if (!child || typeof child !== 'object' ||
+        !{}.propertyIsEnumerable.call( parent, parentName ))
+      return parent;
+
+    path = [ ...path, parentName ];
+    if (Array.isArray(child)) {
+      child.forEach( (n, i) => transformExpression( child, i, transformers, path, ctx ) );
+    }
+    else {
+      for (const childName of Object.getOwnPropertyNames( child )) {
+        if (Array.isArray(transformers))
+          transformers.forEach(t => callT(t, childName, child));
+        else
+          callT(transformers, childName, child);
+        transformExpression(child, childName, transformers, path, ctx);
+      }
+    }
+  }
+  else {
+    for (parentName of Object.getOwnPropertyNames( parent ))
+      transformExpression( parent, parentName, transformers, path, ctx );
+  }
+  return parent;
+}
+
+/**
+ * Drill into an annotation value and inspect each (sub-)object value if it is
+ * an annotation expression. If so, call the real transformExpression that will
+ * execute the callbacks (most likely reference rewriting), continue otherwise
+ *
+ * @param {object} parent Start node
+ * @param {string|number} propName Start at specific property of parent
+ * @param {object} transformers Map of callback functions
+ * @param {CSN.Path} path Path to parent
+ * @returns {object} transformed node
+ */
+function transformAnnotationExpression( parent, propName, transformers, path = [] ) {
   if (propName != null) {
     const child = parent[propName];
     if (!child || typeof child !== 'object' ||
         !{}.propertyIsEnumerable.call( parent, propName ))
       return parent;
 
+    if (isAnnotationExpression(child))
+      return transformExpression(parent, propName, transformers, path, { annoExpr: child });
+
     path = [ ...path, propName ];
     if (Array.isArray(child)) {
-      child.forEach( (n, i) => transformExpression( child, i, transformers, path ) );
+      child.forEach( (n, i) => transformAnnotationExpression( child, i, transformers, path ) );
     }
     else {
-      for (const cpn of Object.getOwnPropertyNames( child )) {
-        if (Array.isArray(transformers))
-          transformers.forEach(t => callT(t, cpn, child));
-        else
-          callT(transformers, cpn, child);
-        transformExpression(child, cpn, transformers, path);
-      }
+      for (const cpn of Object.getOwnPropertyNames( child ))
+        transformAnnotationExpression(child, cpn, transformers, path);
     }
   }
   else {
     for (propName of Object.getOwnPropertyNames( parent ))
-      transformExpression( parent, propName, transformers, path );
+      transformAnnotationExpression( parent, propName, transformers, path );
   }
   return parent;
 }
@@ -384,6 +421,7 @@ function mergeTransformers( transformers, that ) {
 module.exports = {
   mergeTransformers,
   transformExpression,
+  transformAnnotationExpression,
   applyTransformations,
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,

package/lib/transform/draft/odata.js

@@ -2,7 +2,7 @@
 
 const { forEachDefinition, forEachMemberRecursively,
   getServiceNames, applyAnnotationsFromExtensions,
-  transformExpression } = require('../../model/csnUtils');
+  transformAnnotationExpression } = require('../../model/csnUtils');
 const { forEach } = require('../../utils/objectUtils');
 const { isArtifactInSomeService, getServiceOfArtifact } = require('../odata/utils');
 const { getTransformers } = require('../transformUtils');
@@ -231,17 +231,16 @@ function generateDrafts( csn, options, services, messageFunctions ) {
     function $draft2$self(member) {
       Object.keys(member).forEach(pn => {
         if(pn[0] === '@') {
-          let refChanged = false;
-          transformExpression(member, pn,{
-            ref: (_parent, _prop, xpr, _path) => {
-              if(xpr[0] === '$draft') {
-                xpr[0] = '$self';
-                refChanged = true;
+          transformAnnotationExpression(member, pn, {
+              ref: (_parent, _prop, xpr, _path, _p, _ppn, ctx) => {
+                if(xpr[0] === '$draft') {
+                  xpr[0] = '$self';
+                  if(ctx?.annoExpr?.['='])
+                    ctx.annoExpr['='] = true;
+                }
               }
-            }
-          });
-          if (refChanged)
-            member[pn]['='] = true;
+            },
+          );
         }
       });
     }

package/lib/transform/effective/flattening.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  forEachDefinition, forEachMemberRecursively, findAnnotationExpression, applyTransformationsOnNonDictionary, transformExpression,
+  forEachDefinition, forEachMemberRecursively, applyTransformationsOnNonDictionary, transformExpression, transformAnnotationExpression,
 } = require('../../model/csnUtils');
 const { getStructStepsFlattener } = require('../db/flattening');
 const { setProp } = require('../../base/model');
@@ -15,7 +15,7 @@ const { forEach } = require('../../utils/objectUtils');
  * @param csnUtils
  * @param messageFunctions
  */
-function flattenRefs( csn, options, csnUtils, messageFunctions ) {
+function flattenRefs(csn, options, csnUtils, messageFunctions) {
   const cleanup = [];
   forEachDefinition(csn, (artifact) => {
     if (artifact.elements) {
@@ -36,15 +36,11 @@ function flattenRefs( csn, options, csnUtils, messageFunctions ) {
 
           // Absolutify paths in annotation expressions
           Object.keys(element)
-            .filter(pn => findAnnotationExpression(element, pn))
+            .filter(pn => pn.startsWith('@') && element[pn])
             .forEach((anno) => {
-              applyTransformationsOnNonDictionary(element, anno, {
-                xpr: (parent, prop) => {
-                  transformExpression(parent, prop, {
-                    ref: absolutifier,
-                  }, []);
-                },
-              }, {}, []);
+              transformAnnotationExpression(element, anno, {
+                ref: absolutifier,
+              }, []);
               if (element[anno].ref)
                 absolutifier(element[anno], 'ref', element[anno].ref);
             });
@@ -83,17 +79,17 @@ function flattenRefs( csn, options, csnUtils, messageFunctions ) {
               };
 
               Object.keys(a)
-                .filter(pn => findAnnotationExpression(a, pn))
+                .filter(pn => pn.startsWith('@') && a[pn])
                 .forEach((pn) => {
-                  transformExpression(a, pn, [ markBindingParam, refFlattener ], [ 'definitions', defName, 'actions', an ]);
+                  transformAnnotationExpression(a, pn, [ markBindingParam, refFlattener ], [ 'definitions', defName, 'actions', an ]);
                   adaptRefs.forEach(fn => fn(true, 1, parent => parent.$bparam));
                   adaptRefs.length = 0;
                 });
 
 
               forEachMemberRecursively(a, (member, memberName, prop, path) => {
-                Object.keys(member).filter(pn => findAnnotationExpression(member, pn)).forEach((pn) => {
-                  transformExpression(member, pn, [ markBindingParam, refFlattener ], path);
+                Object.keys(member).filter(pn => pn.startsWith('@') && member[pn]).forEach((pn) => {
+                  transformAnnotationExpression(member, pn, [ markBindingParam, refFlattener ], path);
                   adaptRefs.forEach(fn => fn(true, 1, parent => parent.$bparam));
                   adaptRefs.length = 0;
                 });