@sap/cds-compiler 3.1.0 → 3.3.2

package/lib/compiler/assert-consistency.js

@@ -229,11 +229,13 @@ function assertConsistency( model, stage ) {
     elements: { kind: true, inherits: 'definitions', also: [ 0 ] }, // 0 for cyclic expansions
     // specified elements in query entities (TODO: introduce real "specified elements" instead):
     elements$: { kind: true, enumerable: false, test: TODO },
+    enum$: { kind: true, enumerable: false, test: TODO },
     actions: { kind: true, inherits: 'definitions' },
     enum: { kind: true, inherits: 'definitions' },
     foreignKeys: { kind: true, inherits: 'definitions' },
     $keysNavigation: { kind: true, test: TODO },
     params: { kind: true, inherits: 'definitions' },
+    _extendType: { kind: true, test: TODO },
     mixin: { inherits: 'definitions' },
     query: {
       kind: true,
@@ -307,6 +309,7 @@ function assertConsistency( model, stage ) {
       kind: 'element',
       test: isDictionary( definition ), // definition since redef
       requires: [ 'location', 'name' ],
+      optional: [ '$duplicates' ],
     },
     orderBy: { inherits: 'value', test: isArray( expression ) },
     sort: { test: locationVal( isString ), enum: [ 'asc', 'desc' ] },
@@ -330,7 +333,7 @@ function assertConsistency( model, stage ) {
       requires: [ 'location' ],
       optional: [
         'path', 'elements', '_outer', '_parent', '_main', '_block', 'kind',
-        'scope', '_artifact', '$inferred', '$expand', '$tableAliases', '_$next',
+        'scope', '_artifact', '$inferred', '$expand', '$inCycle', '$tableAliases', '_$next',
         '_effectiveType',           // by propagation
       ],
     },
@@ -504,8 +507,8 @@ function assertConsistency( model, stage ) {
       optional: [
         'enum',
         'elements', 'cardinality', 'target', 'on', 'foreignKeys', 'items',
-        '_outer', '_effectiveType', 'notNull',
-        '_origin', '_block', '$inferred', '$expand', '_deps',
+        '_outer', '_effectiveType', 'notNull', '_parent',
+        '_origin', '_block', '$inferred', '$expand', '$inCycle', '_deps',
         '$syntax',
         '_status', '_redirected',
         ...typeProperties,
@@ -602,11 +605,13 @@ function assertConsistency( model, stage ) {
       kind: true,
       test: isOneOf([
         // Uppercase values are used in logic, lowercase value are "just for us", i.e.
-        // debugging or to add non-enumerable properties such as $generated in Universal CSN.
+        // 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
         // as well.
         'IMPLICIT',
         'REDIRECTED',
+        'NULL', // from propagator
+        'prop', // from propagator
 
         '$autoElement', // for magicVars: $user is automatically changed to $user.id
         '$generated', // compiler generated annotations, e.g. @Core.Computed
@@ -618,8 +623,7 @@ function assertConsistency( model, stage ) {
         'composition-entity',
         'copy', // only used in rewriteCondition(): On-condition is copied
         'duplicate-autoexposed', // just like `autoexposed`, but with `duplicate` error.
-        'expand-element', // expanded elements
-        'expand-param',  // expanded params (difference to expand-element only for debugging)
+        'expanded', // expanded elements, items, params
         'include', // through includes, e.g. `entity E : F {}`
         'keys',
         'localized', // e.g. compiler-generated elements for localized: `text` assoc, etc.
@@ -628,6 +632,8 @@ function assertConsistency( model, stage ) {
         'none', // only used in ensureColumnName(): Used in object representing empty alias
         'query', // inferred query properties, e.g. `key`
         'rewrite', // on-conditions or FKeys are rewritten
+        'parent-origin', // annotation/property copied from parent that does not come through
+        //                  $origin and is not a direct annotation
       ]),
     },
 
@@ -639,6 +645,7 @@ function assertConsistency( model, stage ) {
       // See description of `setExpandStatus()` of in `lib/compiler/utils.js`.
       test: isOneOf([ 'origin', 'annotate', 'target' ]),
     },
+    $inCycle: { kind: true, test: isBoolean },
 
     $autoexpose: { kind: [ 'entity' ], test: isBoolean, also: [ null, 'Composition' ] },
     $extra: { parser: true, test: TODO },   // for unexpected properties in CSN

package/lib/compiler/builtins.js

@@ -19,6 +19,10 @@ const core = {
   DecimalFloat: { category: 'decimal', deprecated: true },
   Integer64: { category: 'integer' },
   Integer: { category: 'integer' },
+  UInt8: { category: 'integer' },
+  Int16: { category: 'integer' },
+  Int32: { category: 'integer' },
+  Int64: { category: 'integer' },
   Double: { category: 'decimal' },
   Date: { category: 'dateTime' },
   Time: { category: 'dateTime' },
@@ -54,6 +58,7 @@ const typeParameters = {
     srid: [ 'number' ],
   },
 };
+// a.k.a "typeProperties"
 typeParameters.list = Object.keys( typeParameters.expectedLiteralsFor );
 
 // const hana = {
@@ -137,6 +142,7 @@ const specialFunctions = compileFunctions( {
       separator: [ 'FLAG', 'IN', 'FROM', 'OCCURRENCE', 'GROUP' ],
     },
   ],
+  SUBSTR_REGEXPR: 'SUBSTRING_REGEXPR',
 } );
 
 function compileFunctions( special ) {
@@ -364,6 +370,8 @@ function isInReservedNamespace(absolute) {
  * check against their absolute names.  Builtin types are "cds.<something>", i.e. they
  * are directly in 'cds', but not for example in 'cds.foundation'.
  *
+ * TODO: Handle `{ ref: [ "cds.Integer" ] }`
+ *
  * @param {string} type
  * @returns {boolean}
  */

package/lib/compiler/checks.js

@@ -52,7 +52,7 @@ function check( model ) {       // = XSN
     checkLocalizedSubElement(elem);
     if (elem.key && elem.key.val) {
       if (elem.virtual && elem.virtual.val)
-        error(null, [ elem.location, elem ], 'Element can\'t be virtual and key');
+        error(null, [ elem.location, elem ], {}, 'Element can\'t be virtual and key');
 
       checkForUnmanagedAssociations( elem, elem.key );
     }
@@ -73,7 +73,7 @@ function check( model ) {       // = XSN
     // on it!): The code below misses to consider CSN input.
     if (construct.name.id && construct.name.id.indexOf('.') !== -1) {
       // TODO: No, we should not forbid this
-      error(null, [ construct.name.location, construct ],
+      error(null, [ construct.name.location, construct ], {},
             'The character \'.\' is not allowed in identifiers');
     }
   }
@@ -84,8 +84,8 @@ function check( model ) {       // = XSN
     if (elem.localized && elem.localized.val) {
       const type = elem._effectiveType;
       if (!type || !type.builtin || type.category !== 'string') {
-        warning(null, [ elem.localized.location, elem ], {},
-                'Keyword “localized” may only be used in combination with string types');
+        warning(null, [ elem.type?.location, elem ], { keyword: 'localized' },
+                'Keyword $(KEYWORD) should only be used in combination with string types');
       }
     }
     // "key" keyword at localized element in SELECT list.
@@ -159,7 +159,7 @@ function check( model ) {       // = XSN
     // Special handling to print a more detailed error message.
     // Other cases like `null` as enum value are handled in `checkEnumValueType()`
     if (type === 'enum') {
-      warning('enum-value-ref', [ loc, enumNode ],
+      warning('enum-value-ref', [ loc, enumNode ], {},
               'References to other values are not allowed as enum values');
       return;
     }
@@ -387,7 +387,7 @@ function check( model ) {       // = XSN
       if (elem.cardinality[p[0]] && elem.cardinality[p[1]] &&
           elem.cardinality[p[1]].literal === 'number' &&
           elem.cardinality[p[0]].val > elem.cardinality[p[1]].val) {
-        error(null, [ elem.cardinality.location, elem ],
+        error(null, [ elem.cardinality.location, elem ], {},
               `${ p[2] } minimum cardinality must not be greater than ${ p[2].toLowerCase() } maximum cardinality`);
       }
     });
@@ -422,7 +422,7 @@ function check( model ) {       // = XSN
       if (groupByEntry._artifact && groupByEntry._artifact._effectiveType &&
           groupByEntry._artifact._effectiveType.on) {
         // Unmanaged association - complain
-        error(null, [ groupByEntry.location, art ],
+        error(null, [ groupByEntry.location, art ], {},
               'Unmanaged associations are not allowed in GROUP BY');
       }
     }
@@ -430,7 +430,7 @@ function check( model ) {       // = XSN
       if (orderByEntry._artifact && orderByEntry._artifact._effectiveType &&
           orderByEntry._artifact._effectiveType.on) {
         // Unmanaged association - complain
-        error(null, [ orderByEntry.location, art ],
+        error(null, [ orderByEntry.location, art ], {},
               'Unmanaged associations are not allowed in ORDER BY');
       }
     }
@@ -459,7 +459,7 @@ function check( model ) {       // = XSN
       for (const k in elem.foreignKeys) {
         const key = elem.foreignKeys[k].targetElement;
         if (key && key._artifact && key._artifact.virtual && key._artifact.virtual.val) {
-          error(null, [ key.location, elem ],
+          error(null, [ key.location, elem ], {},
                 'Virtual elements can\'t be used as a foreign key for a managed association');
         }
       }
@@ -517,7 +517,7 @@ function check( model ) {       // = XSN
     if (argTarget.on) {
       const same = path0._artifact === elem;
       if (!same) {
-        error(null, [ path0.location, elem ],
+        error(null, [ path0.location, elem ], {},
               'Unmanaged association condition can\'t follow another unmanaged association');
       }
     }
@@ -527,7 +527,7 @@ function check( model ) {       // = XSN
     if (op && op.val === 'xpr') // no check for xpr
       return;
     if (op && op.val !== '=')
-      error(null, [ op.location, elem ], '$self comparison is only allowed with \'=\'');
+      error(null, [ op.location, elem ], {}, '$self comparison is only allowed with \'=\'');
   }
 
   // A function like this could be part of the compiler
@@ -601,7 +601,7 @@ function check( model ) {       // = XSN
     // Check for illegal argument usage within the expression
     for (const arg of args) {
       if (isVirtualElement(arg))
-        error(null, arg.location, 'Virtual elements can\'t be used in an expression');
+        error(null, arg.location, {}, 'Virtual elements can\'t be used in an expression');
 
 
       // Recursively traverse the argument expression
@@ -624,20 +624,23 @@ function check( model ) {       // = XSN
     // Check for illegal argument usage within the expression
     for (const arg of Array.isArray(xpr.args) && xpr.args || []) { // TODO named args?
       if (isVirtualElement(arg))
-        error(null, arg.location, 'Virtual elements can\'t be used in an expression');
+        error(null, arg.location, {}, 'Virtual elements can\'t be used in an expression');
 
       // Arg must not be an association and not $self
       // Only if path is not approved exists path (that is non-query position)
       if (arg.path && arg.$expected !== undefined) { // not 'approved-exists'
-        if (arg.$expected === 'exists')
-          error(null, arg.location, 'An association can\'t be used as a value in an expression');
+        if (arg.$expected === 'exists') {
+          error(null, arg.location, {},
+                'An association can\'t be used as a value in an expression');
+        }
       }
       else if (!allowAssocTail && isAssociationOperand(arg)) {
-        error(null, arg.location, 'An association can\'t be used as a value in an expression');
+        error(null, arg.location, {},
+              'An association can\'t be used as a value in an expression');
       }
 
       if (isDollarSelfOrProjectionOperand(arg))
-        error(null, arg.location, `"${ arg.path[0].id }" can only be used as a value in a comparison to an association`);
+        error(null, arg.location, {}, `"${ arg.path[0].id }" can only be used as a value in a comparison to an association`);
 
       // Recursively traverse the argument expression
       checkTreeLikeExpression(arg, allowAssocTail);
@@ -736,7 +739,7 @@ function check( model ) {       // = XSN
 
     // Element must exist in annotation
     if (!elementDecl) {
-      warning(null, anno.location || anno.name.location, `Element "${ anno.name.path.map(step => step.id).join('.') }" not found for annotation "${ annoDecl.name.absolute }"`);
+      warning(null, anno.location || anno.name.location, {}, `Element "${ anno.name.path.map(step => step.id).join('.') }" not found for annotation "${ annoDecl.name.absolute }"`);
       return;
     }
 
@@ -747,10 +750,14 @@ function check( model ) {       // = XSN
 
     // Must have literal or path unless it is a boolean
     if (!anno.literal && !anno.path && getFinalTypeNameOf(elementDecl) !== 'cds.Boolean') {
-      if (elementDecl.type && elementDecl.type._artifact.name.absolute)
-        warning(null, anno.location || anno.name.location, `Expecting a value of type "${ elementDecl.type._artifact.name.absolute }" for the annotation`);
-      else
-        warning(null, anno.location || anno.name.location, 'Expecting a value for the annotation');
+      if (elementDecl.type && elementDecl.type._artifact.name.absolute) {
+        warning(null, anno.location || anno.name.location, {},
+                `Expecting a value of type "${ elementDecl.type._artifact.name.absolute }" for the annotation`);
+      }
+      else {
+        warning(null, anno.location || anno.name.location, {},
+                'Expecting a value for the annotation');
+      }
 
       return;
     }
@@ -775,7 +782,7 @@ function check( model ) {       // = XSN
     if (elementDecl._effectiveType.items) {
       // Make sure we have an array value
       if (value.literal !== 'array') {
-        warning(null, loc, 'An array value is required here');
+        warning(null, loc, {}, 'An array value is required here');
         return;
       }
       // Check each element
@@ -788,7 +795,7 @@ function check( model ) {       // = XSN
     // Struct expected (can only happen within arrays)?
     if (elementDecl._effectiveType.elements) {
       if (value.literal !== 'struct') {
-        warning(null, loc, 'A struct value is required here');
+        warning(null, loc, {}, 'A struct value is required here');
         return;
       }
       // FIXME: Should check each element
@@ -800,28 +807,28 @@ function check( model ) {       // = XSN
     if (builtins.isStringTypeName(type)) {
       if (value.literal !== 'string' && value.literal !== 'enum' &&
           !elementDecl._effectiveType.enum)
-        warning(null, loc, `A string value is required for type "${ type }"`);
+        warning(null, loc, {}, `A string value is required for type "${ type }"`);
     }
     else if (builtins.isBinaryTypeName(type)) {
       if (value.literal !== 'string' && value.literal !== 'x')
-        warning(null, loc, `A hexadecimal string value is required for type "${ type }"`);
+        warning(null, loc, {}, `A hexadecimal string value is required for type "${ type }"`);
     }
     else if (builtins.isNumericTypeName(type)) {
       if (value.literal !== 'number' && value.literal !== 'enum' &&
           !elementDecl._effectiveType.enum)
-        warning(null, loc, `A numerical value is required for type "${ type }"`);
+        warning(null, loc, {}, `A numerical value is required for type "${ type }"`);
     }
     else if (builtins.isDateOrTimeTypeName(type)) {
       if (value.literal !== 'date' && value.literal !== 'time' &&
           value.literal !== 'timestamp' && value.literal !== 'string')
-        warning(null, loc, `A date/time value or a string is required for type "${ type }"`);
+        warning(null, loc, {}, `A date/time value or a string is required for type "${ type }"`);
     }
     else if (builtins.isBooleanTypeName(type)) {
       if (value.literal && value.literal !== 'boolean')
-        warning(null, loc, `A boolean value is required for type "${ type }"`);
+        warning(null, loc, {}, `A boolean value is required for type "${ type }"`);
     }
     else if (builtins.isRelationTypeName(type) || builtins.isGeoTypeName(type)) {
-      warning(null, loc, `Type "${ type }" can't be assigned a value`);
+      warning(null, loc, {}, `Type "${ type }" can't be assigned a value`);
     }
     else {
       throw new Error(`Unknown primitive type name: ${ type }`);
@@ -834,19 +841,19 @@ function check( model ) {       // = XSN
         // Enum symbol provided and expected
         if (!expectedEnum[value.sym.id]) {
           // .. but no such constant
-          warning(null, loc, `Enum symbol "#${ value.sym.id }" not found in enum`);
+          warning(null, loc, {}, `Enum symbol "#${ value.sym.id }" not found in enum`);
         }
       }
       else {
         // Enum symbol provided but not expected
-        warning(null, loc, `Cannot use enum symbol "#${ value.sym.id }" for non-enum type "${ type }"`);
+        warning(null, loc, {}, `Can't use enum symbol "#${ value.sym.id }" for non-enum type "${ type }"`);
       }
     }
     else if (expectedEnum) {
       // Enum symbol not provided but expected
       if (!Object.keys(expectedEnum).some(symbol => expectedEnum[symbol].value.val === value.val)) {
         // ... and none of the valid enum symbols matches the value
-        warning(null, loc, 'An enum value is required here');
+        warning(null, loc, {}, 'An enum value is required here');
       }
     }
   }

package/lib/compiler/define.js

@@ -7,7 +7,7 @@
 // Definitions inside a context are not listed here (as opposed to
 // `definitions`, see below), but inside the property `artifacts` of that context.
 
-// The define phase (function 'define' below) enriches a dictionary of
+// The 'define' phase (function 'define' below) enriches a dictionary of
 // (file names to) AST-like CSNs and restructure them a little bit, the result
 // is called "augmented CSN":
 //   { sources: <dictionary of ASTs>, definitions: <dictionary of artifact defs> }
@@ -194,7 +194,7 @@ function define( model ) {
     dictForEach( model.definitions, initArtifact );
     dictForEach( model.vocabularies, initVocabulary );
 
-    mergeI18nBlocks( model );
+    mergeI18nBlocks();
   }
 
   // Phase 1: ----------------------------------------------------------------
@@ -213,9 +213,8 @@ function define( model ) {
     let namespace = src.namespace && src.namespace.path;
     let prefix = namespace ? `${ pathName( namespace ) }.` : '';
     if (isInReservedNamespace(prefix)) {
-      error( 'reserved-namespace-cds', [ src.namespace.location, src.namespace ], {},
-             // TODO: use $(NAME)
-             'The namespace "cds" is reserved for CDS builtins' );
+      error( 'reserved-namespace-cds', [ src.namespace.location, src.namespace ], { name: 'cds' },
+             'The namespace $(NAME) is reserved for CDS builtins' );
       namespace = null;
     }
     if (src.$frontend !== 'json') { // CDL input
@@ -249,9 +248,8 @@ function define( model ) {
     const { absolute } = art.name;
     // TODO: check reserved, see checkName()/checkLocalizedObjects() of checks.js
     if (absolute === 'cds' || isInReservedNamespace(absolute)) {
-      error( 'reserved-namespace-cds', [ art.name.location, art ], {},
-             // TODO: use $(NAME)
-             'The namespace "cds" is reserved for CDS builtins' );
+      error( 'reserved-namespace-cds', [ art.name.location, art ], { name: 'cds' },
+             'The namespace $(NAME) is reserved for CDS builtins' );
       const builtin = model.definitions[absolute];
       if (builtin && builtin.builtin) // if already a builtin...
         return;
@@ -259,8 +257,6 @@ function define( model ) {
     }
     else if (art.query && (absolute === 'localized' || absolute.startsWith( 'localized.' ))) {
       // Due to recompilation, we don't emit this info message for JSON frontend.
-      // TODO: generalize this for $generated (definitions starting with
-      // "localized" just have `$generated: true` as default)
       if (block.$frontend !== 'json') {
         info( 'ignored-localized-definition', [ art.name.location, art ], {},
               'This definition in the namespace "localized" is ignored' );
@@ -419,6 +415,8 @@ function define( model ) {
   }
 
   function initNamespaceAndUsing( src ) {
+    if (src.$frontend && src.$frontend !== 'cdl')
+      return;
     if (src.namespace) {
       const decl = src.namespace;
       const { path } = decl;
@@ -478,12 +476,16 @@ function define( model ) {
     if (!setLink( art, '_leadingQuery', initQueryExpression( art.query, art ) ) )
       return;                   // null or undefined in case of parse error
     setLink( art._leadingQuery, '_$next', art );
-    // the following we be removed soon if we have:
+    // the following may be removed soon if we have:
     // view elements as proxies to elements of leading query
     if (art.elements) { // specified element via compilation of client-style CSN
       setLink( art, 'elements$', art.elements );
       delete art.elements;
     }
+    if (art.enum) { // specified enum via compilation of client-style CSN
+      setLink( art, 'enum$', art.enum );
+      delete art.enum;
+    }
   }
 
   function initVocabulary( art ) {
@@ -607,13 +609,13 @@ function define( model ) {
         defineAnnotations( col, col, parent._block );
         if (col.inline) { // `@anno elem.{ * }` does not work
           if (col.doc)
-            warning( 'syntax-anno-ignored', [ col.doc.location, col ], { '#': 'doc' } );
+            warning( 'syntax-ignoring-anno', [ col.doc.location, col ], { '#': 'doc' } );
 
           // col.$annotations no available for CSN input, have to search.
           // Warning about first annotation should be enough to avoid spam.
           const firstAnno = Object.keys(col).find(key => key.startsWith('@'));
           if (firstAnno)
-            warning( 'syntax-anno-ignored', [ col[firstAnno].name.location, col ] );
+            warning( 'syntax-ignoring-anno', [ col[firstAnno].name.location, col ] );
         }
         // TODO: allow sub queries? at least in top-level expand without parallel ref
         if (columns)
@@ -658,7 +660,7 @@ function define( model ) {
 
   /**
    * If we have a valid top-level exists, exists in filters of sub-expressions can be translated,
-   * since we will have a top-level subquery after exists-processing in the forHanaNew.
+   * since we will have a top-level subquery after exists-processing in the forRelationalDB.
    *
    * Recursively drill down into:
    * - the .path
@@ -886,17 +888,21 @@ function define( model ) {
   /**
    * Set property `_parent` for all elements in `parent` to `parent` and do so
    * recursively for all sub elements.
+   *
+   * If not for extensions: construct === parent
    */
-  // If not for extensions: construct === parent
   function initMembers( construct, parent, block, initExtensions = false ) {
     // TODO: split extend from init
     const isQueryExtension = kindProperties[construct.kind].isExtension &&
           (parent._main || parent).query;
     let obj = construct;
-    if (obj.items) {            // TODO: while
-      setLink( obj.items, '_outer', obj );
-      obj = obj.items;          // TODO: probably set parent = obj (is so in csnRefs)
-      setLink( obj, '_block', block );
+    let { items } = obj;
+    while (items) {
+      setLink( items, '_outer', obj );
+      setLink( items, '_parent', obj._parent );
+      setLink( items, '_block', block );
+      obj = items;
+      items = obj.items;
     }
     if (obj.target && targetIsTargetAspect( obj )) {
       obj.targetAspect = obj.target;
@@ -913,7 +919,7 @@ function define( model ) {
       if (obj.on && !obj.target) {
         error( 'unexpected-on-for-composition', [ obj.on.location, construct ],
                {},
-               'A managed aspect composition can\'t have a specified ON condition' );
+               'A managed aspect composition can\'t have a specified ON-condition' );
         delete obj.on;          // continuation semantics: not specified
       }
       if (targetAspect.elements) {
@@ -1017,7 +1023,7 @@ function define( model ) {
       setMemberParent( elem, name, parent, construct !== parent && prop );
       // console.log(message( null, elem.location, elem, {}, 'Info', 'INIT').toString())
       checkRedefinition( elem );
-      if (elem.kind === 'annotate')
+      if (elem.kind === 'annotate' || elem.kind === 'extend')
         checkAnnotate( elem, elem );
       defineAnnotations( elem, elem, bl );
       initMembers( elem, elem, bl, initExtensions );
@@ -1039,7 +1045,7 @@ function define( model ) {
                    std: 'Elements can\'t have a value',
                    entity: 'Entity elements can\'t have a value',
                    type: 'Type elements can\'t have a value',
-                   extend: 'Cannot extend type/entity elements with values',
+                   extend: 'Can\'t extend type/entity elements with values',
                  });
           return;
         }
@@ -1072,8 +1078,11 @@ function define( model ) {
              'Actions and functions only exist top-level and for entities' );
     }
     else if (parent.kind === 'action' || parent.kind === 'function') {
-      error( 'extend-action', [ construct.location, construct ], {},
-             'Actions and functions can\'t be extended, only annotated' );
+      error( 'extend-action', [ construct.location, construct ], { '#': parent.kind }, {
+        std: 'Actions and functions can\'t be extended, only annotated',
+        action: 'Actions can\'t be extended, only annotated',
+        function: 'Functions can\'t be extended, only annotated',
+      } );
     }
     else if (prop === 'params') {
       if (!feature) {
@@ -1105,29 +1114,27 @@ function define( model ) {
     }
     return construct === parent;
   }
-}
 
-/**
- * Merge (optional) translations into the XSN model.
- *
- * @param {XSN.Model} model
- */
-function mergeI18nBlocks( model ) {
-  const sortedSources = Object.keys(model.sources)
-    .filter(name => !!model.sources[name].i18n)
-    .sort( (a, b) => compareLayer( model.sources[a], model.sources[b] ) );
+  /**
+   * Merge (optional) translations into the XSN model.
+   */
+  function mergeI18nBlocks() {
+    const sortedSources = Object.keys(model.sources)
+      .filter(name => !!model.sources[name].i18n)
+      .sort( (a, b) => compareLayer( model.sources[a], model.sources[b] ) );
 
-  if (sortedSources.length === 0)
-    return;
+    if (sortedSources.length === 0)
+      return;
 
-  if (!model.i18n)
-    model.i18n = Object.create( null );
+    if (!model.i18n)
+      model.i18n = Object.create( null );
 
-  for (const name of sortedSources)
-    initI18nFromSource( model.sources[name] );
+    for (const name of sortedSources)
+      initI18nFromSource( model.sources[name] );
+  }
 
   /**
-   * Add the source's translations to the model. Warns if the sources translations
+   * Add the source's translations to the model. Warns if the source's translations
    * do not match the ones from previous sources.
    *
    * @param {XSN.SourceAst} src
@@ -1144,9 +1151,8 @@ function mergeI18nBlocks( model ) {
           model.i18n[langKey][textKey] = sourceVal;
         }
         else if (modelVal.val !== sourceVal.val) {
-          // TODO: put mergeI18nBlocks() into main function instead
-          model.$messageFunctions.warning( 'i18n-different-value', sourceVal.location,
-                                           { prop: textKey, otherprop: langKey } );
+          warning( 'i18n-different-value', sourceVal.location,
+                   { prop: textKey, otherprop: langKey } );
         }
       }
     }