@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/compiler/generate.js

@@ -18,6 +18,7 @@ const {
   isDirectComposition,
   copyExpr,
 } = require('./utils');
+const { weakLocation } = require('../base/messages');
 
 function generate( model ) {
   const { options } = model;
@@ -33,7 +34,7 @@ function generate( model ) {
     applyIncludes,
   } = model.$functions;
 
-  const addTextsLanguageAssoc = checkTextsLanguageAssocOption(model, options);
+  const addTextsLanguageAssoc = checkTextsLanguageAssocOption( model, options );
   const useTextsAspect = checkTextsAspect();
 
   Object.keys( model.definitions ).forEach( processArtifact );
@@ -63,14 +64,14 @@ function generate( model ) {
    */
   function compositionChildPersistence() {
     const processed = new WeakSet();
-    forEachDefinition(model, processCompositionPersistence);
+    forEachDefinition( model, processCompositionPersistence );
 
     function processCompositionPersistence( def ) {
-      if (def.$inferred === 'composition-entity' && !processed.has(def)) {
+      if (def.$inferred === 'composition-entity' && !processed.has( def )) {
         if (def._parent)
-          processCompositionPersistence(def._parent);
+          processCompositionPersistence( def._parent );
         copyPersistenceAnnotations( def, def._parent );
-        processed.add(def);
+        processed.add( def );
       }
     }
   }
@@ -90,18 +91,18 @@ function generate( model ) {
     const specialElements = { locale: { key: true } };
 
     if (textsAspect.kind !== 'aspect' || !textsAspect.elements) {
-      error('def-invalid-texts-aspect', [ textsAspect.name.location, textsAspect ],
-            { '#': 'no-aspect', art: textsAspect });
+      error( 'def-invalid-texts-aspect', [ textsAspect.name.location, textsAspect ],
+             { '#': 'no-aspect', art: textsAspect } );
       return false;
     }
 
     let hasError = false;
     if (addTextsLanguageAssoc && textsAspect.elements.language) {
       const lang = textsAspect.elements.language;
-      error('def-unexpected-element', [ lang.name.location, lang ],
-            { option: 'addTextsLanguageAssoc', art: textsAspect, name: 'language' },
-            // eslint-disable-next-line max-len
-            '$(ART) is not used because option $(OPTION) conflicts with existing element $(NAME); remove either option or element' );
+      error( 'def-unexpected-element', [ lang.name.location, lang ],
+             { option: 'addTextsLanguageAssoc', art: textsAspect, name: 'language' },
+        // eslint-disable-next-line max-len
+             '$(ART) is not used because option $(OPTION) conflicts with existing element $(NAME); remove either option or element' );
       hasError = true;
     }
 
@@ -109,14 +110,14 @@ function generate( model ) {
       const expected = specialElements[name];
       const elem = textsAspect.elements[name];
       if (!elem) {
-        error('def-invalid-texts-aspect', [ textsAspect.name.location, textsAspect ],
-              { '#': 'missing', art: textsAspect, name });
+        error( 'def-invalid-texts-aspect', [ textsAspect.name.location, textsAspect ],
+               { '#': 'missing', art: textsAspect, name } );
         hasError = true;
       }
       else if (expected.key !== undefined && !!elem.key?.val !== expected.key) {
         const loc = elem.key?.location || elem.name?.location || textsAspect.name.location;
-        error('def-invalid-texts-aspect', [ loc, elem ],
-              { '#': expected.key ? 'key' : 'no-key', art: elem });
+        error( 'def-invalid-texts-aspect', [ loc, elem ],
+               { '#': expected.key ? 'key' : 'no-key', art: elem } );
         hasError = true;
       }
     }
@@ -193,9 +194,9 @@ function generate( model ) {
     // usual include-mechanism.
     const protectedElements = [ 'locale', 'texts', 'localized' ];
     if (fioriEnabled)
-      protectedElements.push('ID_texts');
+      protectedElements.push( 'ID_texts' );
     if (addTextsLanguageAssoc)
-      protectedElements.push('language');
+      protectedElements.push( 'language' );
 
     for (const name in art.elements) {
       const elem = art.elements[name];
@@ -215,9 +216,10 @@ function generate( model ) {
         textElems.push( elem );
       }
 
-      if (isKey && isLocalized) { // key with localized is wrong - ignore localized
+      if (isKey && isLocalized) {
         const errpos = elem.localized || elem.type || elem.name;
-        warning( 'def-ignoring-localized-key', [ errpos.location, elem ], { keyword: 'localized' },
+        warning( 'def-ignoring-localized', [ errpos.location, elem ],
+                 { keyword: 'localized' },
                  'Keyword $(KEYWORD) is ignored for primary keys' );
       }
     }
@@ -342,8 +344,8 @@ function generate( model ) {
       // Because ID_texts is not copied from TextsAspect, the order is messed
       // up.  Fix it.
       const { elements } = art;
-      art.elements = Object.create(null);
-      const names = [ 'ID_texts', 'locale', ...Object.keys(elements) ];
+      art.elements = Object.create( null );
+      const names = [ 'ID_texts', 'locale', ...Object.keys( elements ) ];
       for (const name of names)
         art.elements[name] = elements[name];
 
@@ -373,7 +375,7 @@ function generate( model ) {
   function createTextsEntityWithInclude( base, absolute, fioriEnabled ) {
     const textsAspectName = 'sap.common.TextsAspect';
     const textsAspect = model.definitions['sap.common.TextsAspect'];
-    const elements = Object.create(null);
+    const elements = Object.create( null );
     const { location } = base.name;
     const art = {
       kind: 'entity',
@@ -386,7 +388,6 @@ function generate( model ) {
 
     if (!fioriEnabled) {
       // To be compatible, we switch off draft without @fiori.draft.enabled
-      // TODO (next major version): remove?
       setAnnotation( art, '@odata.draft.enabled', art.location, false );
     }
     else {
@@ -422,7 +423,7 @@ function generate( model ) {
    * @param {boolean} fioriEnabled
    */
   function createTextsEntityWithDefaultElements( base, absolute, fioriEnabled ) {
-    const elements = Object.create(null);
+    const elements = Object.create( null );
     const { location } = base.name;
     const art = {
       kind: 'entity',
@@ -446,7 +447,6 @@ function generate( model ) {
     if (!fioriEnabled) {
       locale.key = { val: true, location };
       // To be compatible, we switch off draft without @fiori.draft.enabled
-      // TODO (next major version): remove?
       setAnnotation( art, '@odata.draft.enabled', art.location, false );
     }
     else {
@@ -536,7 +536,7 @@ function generate( model ) {
    * @returns {boolean}
    */
   function hasTruthyProp( art, prop ) {
-    const processed = Object.create(null); // avoid infloops with circular refs
+    const processed = Object.create( null ); // avoid infloops with circular refs
     let name = art.name.absolute;        // is ok, since no recursive type possible
     while (art && !processed[name]) {
       if (art[prop])
@@ -576,7 +576,7 @@ function generate( model ) {
     return;
 
     function baseKeys() {
-      const k = Object.create(null);
+      const k = Object.create( null );
       for (const name in base.elements) {
         const elem = base.elements[name];
         if (elem.$duplicates)
@@ -662,22 +662,22 @@ function generate( model ) {
       return false;
     }
     const names = Object.keys( target.elements )
-      .filter( n => n.startsWith('up__') && keyNames.includes( n.substring(4) ) );
+      .filter( n => n.startsWith( 'up__' ) && keyNames.includes( n.substring(4) ) );
     if (names.length) {
       // FUTURE: if named type, add sub info with location of "up_" element
       error( null, [ location, elem ], { target: entityName, names }, {
         std: 'Key elements $(NAMES) can\'t be added to $(TARGET) as these already exist',
         one: 'Key element $(NAMES) can\'t be added to $(TARGET) as it already exist',
-      });
+      } );
       return false;
     }
 
-    if (elem.type && !isDirectComposition(elem)) {
+    if (elem.type && !isDirectComposition( elem )) {
       // Only issue warning for direct usages, not for projections, includes, etc.
       // TODO: Make it configurable error; v4: error
       warning( 'def-expected-comp-aspect', [ elem.type.location, elem ],
                { prop: 'Composition of', otherprop: 'Association to' },
-               'Expected $(PROP), but found $(OTHERPROP) for composition of aspect');
+               'Expected $(PROP), but found $(OTHERPROP) for composition of aspect' );
     }
 
     return true;
@@ -697,9 +697,14 @@ function generate( model ) {
 
     const art = {
       kind: 'entity',
-      name: { path: splitIntoPath( location, entityName ), absolute: entityName, location },
+      name: {
+        path: splitIntoPath( location, entityName ),
+        absolute: entityName,
+        // for code navigation (e.g. via `extend`s): point to the element's name
+        location: elem.name.location,
+      },
       location,
-      elements: Object.create(null),
+      elements: Object.create( null ),
       $inferred: 'composition-entity',
     };
     if (target.name) {          // named target aspect
@@ -712,17 +717,19 @@ function generate( model ) {
       setLink( art, '_upperAspects', elem._main._upperAspects || [] );
     }
 
+    // Since there is no user-written up_ element, use a weak location to the beginning of {…}.
+    const upLocation = weakLocation( location );
     const up = { // elements.up_ = ...
-      name: { location, id: 'up_' },
+      name: { location: upLocation, id: 'up_' },
       kind: 'element',
-      location,
+      location: upLocation,
       $inferred: 'aspect-composition',
-      type: augmentPath( location, 'cds.Association' ),
-      target: augmentPath( location, base.name.absolute ),
+      type: augmentPath( upLocation, 'cds.Association' ),
+      target: augmentPath( upLocation, base.name.absolute ),
       cardinality: {
-        targetMin: { val: 1, literal: 'number', location },
-        targetMax: { val: 1, literal: 'number', location },
-        location,
+        targetMin: { val: 1, literal: 'number', location: upLocation },
+        targetMax: { val: 1, literal: 'number', location: upLocation },
+        location: upLocation,
       },
     };
     // By default, 'up_' is a managed primary key association.
@@ -731,16 +738,17 @@ function generate( model ) {
     if (isDeprecatedEnabled( options, '_unmanagedUpInComponent' )) {
       addProxyElements( art, keys, 'aspect-composition', target.name && location,
                         'up__', '@odata.containment.ignore' );
-      up.on = augmentEqual( location, 'up_', Object.values( keys ), 'up__' );
+      up.on = augmentEqual( upLocation, 'up_', Object.values( keys ), 'up__' );
     }
     else {
-      up.key = { location, val: true };
+      up.key = { location: upLocation, val: true };
       // managed associations must be explicitly set to not null
       // even if target cardinality is 1..1
-      up.notNull = { location, val: true };
+      up.notNull = { location: upLocation, val: true };
     }
 
-    dictAdd( art.elements, 'up_', up);
+    dictAdd( art.elements, 'up_', up );
+    // Only for named aspects, use a new location; otherwise use the origin's one.
     addProxyElements( art, target.elements, 'aspect-composition', target.name && location );
 
     setLink( art, '_block', model.$internal );
@@ -758,7 +766,7 @@ function generate( model ) {
     for (const name in elements) {
       const pname = `${ prefix }${ name }`;
       const origin = elements[name];
-      const proxy = linkToOrigin( origin, pname, null, null, location || origin.location );
+      const proxy = linkToOrigin( origin, pname, null, null, location, true );
       setLink( proxy, '_block', origin._block );
       proxy.$inferred = inferred;
       if (origin.masked)
@@ -809,7 +817,7 @@ function augmentEqual( location, assocname, relations, prefix = '' ) {
     : { op: { val: 'and', location }, args, location };
 
   function eq( refs ) {
-    if (Array.isArray(refs))
+    if (Array.isArray( refs ))
       return { op: { val: '=', location }, args: refs.map( ref ), location };
 
     const { id } = refs.name;
@@ -823,7 +831,7 @@ function augmentEqual( location, assocname, relations, prefix = '' ) {
     };
   }
   function ref( path ) {
-    return { path: path.split('.').map( id => ({ id, location }) ), location };
+    return { path: path.split( '.' ).map( id => ({ id, location }) ), location };
   }
 }
 
@@ -834,12 +842,12 @@ function checkTextsLanguageAssocOption( model, options ) {
   if (options.addTextsLanguageAssoc && !commonLanguagesEntity) {
     const variant = !languages ? 'std' : 'code';
     const loc = model.definitions['sap.common.Languages']?.name?.location || null;
-    model.$messageFunctions.info('api-ignoring-language-assoc', loc, {
+    model.$messageFunctions.info( 'api-ignoring-language-assoc', loc, {
       '#': variant, option: 'addTextsLanguageAssoc', art: 'sap.common.Languages', name: 'code',
     }, {
       std: 'Ignoring option $(OPTION) because entity $(ART) is missing',
       code: 'Ignoring option $(OPTION) because entity $(ART) is missing element $(NAME)',
-    });
+    } );
   }
 
   return !!commonLanguagesEntity;

package/lib/compiler/index.js

@@ -12,7 +12,7 @@
 
 'use strict';
 
-const { resolveModule, resolveModuleSync } = require('../utils/moduleResolve');
+const { makeModuleResolver, makeModuleResolverSync } = require('../utils/moduleResolve');
 const parseLanguage = require('../language/antlrParser'); // TODO: should we do some lazyload here?
 const parseCsn = require('../json/from-csn');
 
@@ -38,6 +38,7 @@ const { cdsFs } = require('../utils/file');
 
 const fs = require('fs');
 const path = require('path');
+const { CsnLocation, XsnSource } = require('./classes');
 
 const extensionParsers = {
   csn: parseCsn.parse,
@@ -52,7 +53,7 @@ const extensionParsers = {
 //  `errors`: vector of errors (file IO or ArgumentError)
 class InvocationError extends Error {
   constructor( errs, ...args ) {
-    super(...args);
+    super( ...args );
     this.code = 'ERR_CDS_COMPILER_INVOCATION';
     this.errors = errs;
     this.hasBeenReported = false;
@@ -63,7 +64,7 @@ class InvocationError extends Error {
 //  `argument`: the command argument (repeated file names)
 class ArgumentError extends Error {
   constructor( arg, ...args ) {
-    super(...args);
+    super( ...args );
     this.code = 'ERR_CDS_COMPILER_ARGUMENT';
     this.argument = arg;
   }
@@ -85,14 +86,15 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
   const ext = path.extname( filename ).slice(1).toLowerCase();
   // eslint-disable-next-line no-nested-ternary
   const parser = options.fallbackParser === 'auto!'
-    ? (source?.startsWith('{') ? parseCsn.parse : parseLanguage)
+    ? (source?.startsWith( '{' ) ? parseCsn.parse : parseLanguage)
     : (extensionParsers[ext] || extensionParsers[options.fallbackParser] ||
-       source.startsWith('{') && parseCsn.parse);
+       source.startsWith( '{' ) && parseCsn.parse);
   if (parser)
     return parser( source, filename, options, messageFunctions );
 
-  const model = { location: { file: filename } };
-  messageFunctions.error( 'file-unknown-ext', emptyWeakLocation(filename),
+  const model = new XsnSource();
+  model.location = new CsnLocation( filename );
+  messageFunctions.error( 'file-unknown-ext', emptyWeakLocation( filename ),
                           { file: ext, '#': !ext && 'none' }, {
                             std: 'Unknown file extension $(FILE)',
                             none: 'No file extension',
@@ -129,29 +131,30 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
 //  - 'string' or instanceof Buffer: the file content
 //  - { realname: fs.realpath(filename) }: if filename is not canonicalized
 //
-function compileX( filenames, dir = '', options = {}, fileCache = Object.create(null) ) {
+function compileX( filenames, dir = '', options = {}, fileCache = Object.create( null ) ) {
   // A non-proper dictionary (i.e. with prototype) is safe if the keys are
   // absolute file names - they start with `/` or `\` or similar
   // if (Object.getPrototypeOf( fileCache ))
   //   fileCache = Object.assign( Object.create(null), fileCache );
-  dir = path.resolve(dir);
+  dir = path.resolve( dir );
   const model = { sources: null, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
+  const { resolveModule } = makeModuleResolver( options, fileCache, model.$messageFunctions );
   let input = null;
 
   let all = processFilenames( filenames, dir )
-    .then((processedInput) => {
+    .then( (processedInput) => {
       input = processedInput;
       model.sources = input.sources;
-    })
-    .then(() => promiseAllDoNotRejectImmediately( input.files.map(readAndParse) ))
+    } )
+    .then( () => promiseAllDoNotRejectImmediately( input.files.map( readAndParse ) ) )
     .then( testInvocation, (reason) => {
       // do not reject with PromiseAllError, use InvocationError:
       const errs = reason.valuesOrErrors.filter( e => e instanceof Error );
       // internal error if no file IO error (has property `path`)
       return Promise.reject( errs.find( e => !e.path ) ||
                              new InvocationError( [ ...input.repeated, ...errs ]) );
-    });
+    } );
 
   if (!options.parseOnly && !options.parseCdl)
     all = all.then( readDependencies );
@@ -159,7 +162,7 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
   return all.then( () => {
     moduleLayers.setLayers( input.sources );
     return compileDoX( model );
-  });
+  } );
 
   // Read file `filename` and parse its content, return messages
   async function readAndParse( filename ) {
@@ -171,12 +174,12 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
       return [];                 // no further dependency processing
     // no parallel readAndParse with same resolved filename should read the file,
     // also ensure deterministic sequence in sources:
-    sources[filename] = { location: { file: rel } };
+    sources[filename] = { location: new CsnLocation( rel ) };
 
     const source = await cdsFs( fileCache, options.traceFs ).readFileAsync( filename, 'utf8' );
     const ast = parseX( source, rel, options, model.$messageFunctions );
     sources[filename] = ast;
-    ast.location = { file: rel };
+    ast.location = new CsnLocation( rel );
     ast.dirname = path.dirname( filename );
     assertConsistency( ast, options );
 
@@ -208,10 +211,8 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
       }
       // create promises after all usingFroms have been collected, as the
       // Promise executor is called immediately with `new`:
-      for (const module in dependencies) {
-        promises.push( resolveModule( dependencies[module], fileCache, options,
-                                      model.$messageFunctions ) );
-      }
+      for (const module in dependencies)
+        promises.push( resolveModule( dependencies[module] ) );
     }
     if (!promises.length)
       return [];
@@ -234,23 +235,25 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
  * @param {object} [fileCache]
  * @returns {XSN.Model} Augmented CSN
  */
-function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.create(null) ) {
+function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.create( null ) ) {
   // A non-proper dictionary (i.e. with prototype) is safe if the keys are
   // absolute file names - they start with `/` or `\` or similar
-  dir = path.resolve(dir);
+  dir = path.resolve( dir );
   const a = processFilenamesSync( filenames, dir );
 
   const model = { sources: a.sources, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
+  const { resolveModuleSync } = makeModuleResolverSync( options, fileCache,
+                                                        model.$messageFunctions );
 
   const asts = [];
   const errors = [];
   a.files.forEach( val => readAndParseSync( val, (err, ast) => {
     if (err)
-      errors.push(err);
+      errors.push( err );
     if (ast)
-      asts.push(ast);
-  }));
+      asts.push( ast );
+  } ) );
 
   if (errors.length || a.repeated.length) {
     // internal error if no file IO error (has property `path`)
@@ -264,12 +267,12 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
       asts.length = 0;
       // Push dependencies to `ast`. Only works because readAndParseSync() is synchronous.
       for (const fileName of fileNames) {
-        readAndParseSync(fileName, ( err, ast ) => {
+        readAndParseSync( fileName, ( err, ast ) => {
           if (err)
             throw err;
           if (ast)
             asts.push( ast );
-        });
+        } );
       }
     }
   }
@@ -280,36 +283,36 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
   // Read file `filename` and parse its content, return messages
   function readAndParseSync( filename, cb ) {
     if ( filename === false ) {   // module which has not been found
-      cb(null, null);
+      cb( null, null );
       return;
     }
     const rel = a.sources[filename] || path.relative( dir, filename );
     if (typeof rel === 'object') { // already parsed
-      cb(null, null);
+      cb( null, null );
       return;                 // no further dependency processing
     }
     // no parallel readAndParse with same resolved filename should read the file,
     // also ensure deterministic sequence in a.sources:
-    a.sources[filename] = { location: { file: rel } };
+    a.sources[filename] = { location: new CsnLocation( rel ) };
 
     cdsFs( fileCache, options.traceFs ).readFileSync( filename, 'utf8', (err, source) => {
       if (err) {
-        cb(err, null);
+        cb( err, null );
       }
       else {
         try {
           const ast = parseX( source, rel, options, model.$messageFunctions );
           a.sources[filename] = ast;
-          ast.location = { file: rel };
+          ast.location = new CsnLocation( rel );
           ast.dirname = path.dirname( filename );
           assertConsistency( ast, options );
           cb( null, ast );
         }
         catch (e) {
-          cb(e, null);
+          cb( e, null );
         }
       }
-    });
+    } );
   }
 
   function readDependenciesSync( astArray ) {
@@ -329,10 +332,8 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
       }
       // create promises after all usingFroms have been collected, as the
       // Promise executor is called immediately with `new`:
-      for (const module in dependencies) {
-        fileNames.push( resolveModuleSync( dependencies[module], fileCache, options,
-                                           model.$messageFunctions ) );
-      }
+      for (const module in dependencies)
+        fileNames.push( resolveModuleSync( dependencies[module] ) );
     }
     if (!fileNames.length)
       return [];
@@ -364,7 +365,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
 function compileSourcesX( sourcesDict, options = {} ) {
   if (typeof sourcesDict === 'string')
     sourcesDict = { '<stdin>.cds': sourcesDict };
-  const sources = Object.create(null);
+  const sources = Object.create( null );
   const model = { sources, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
 
@@ -373,7 +374,7 @@ function compileSourcesX( sourcesDict, options = {} ) {
     if (typeof source === 'string') {
       const ast = parseX( source, filename, options, model.$messageFunctions );
       sources[filename] = ast;
-      ast.location = { file: filename };
+      ast.location = new CsnLocation( filename );
       assertConsistency( ast, options );
     }
     else if (options.$xsnObjects) { // source is a XSN object with option $xsnObjects
@@ -382,7 +383,7 @@ function compileSourcesX( sourcesDict, options = {} ) {
     else {                      // source is a CSN object
       const ast = parseCsn.augment( source, filename, options, model.$messageFunctions );
       sources[filename] = ast;
-      ast.location = { file: filename };
+      ast.location = new CsnLocation( filename );
       assertConsistency( ast, options );
     }
 
@@ -422,9 +423,9 @@ function recompileX( csn, options ) {
   // TODO: $recompile: true should be enough
 
   const file = csn.$location && csn.$location.file &&
-    csn.$location.file.replace(/[.]cds$/, '.cds.csn') || '<recompile>.csn';
+    csn.$location.file.replace( /[.]cds$/, '.cds.csn' ) || '<recompile>.csn';
 
-  const sources = Object.create(null);
+  const sources = Object.create( null );
   const model = { sources, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
   // TODO: or use module which invokes the recompilation?
@@ -433,7 +434,7 @@ function recompileX( csn, options ) {
   moduleLayers.setLayers( sources );
   const compiled = compileDoX( model ); // calls throwWithError()
   if (options.messages)         // does not help with exception in compileDoX()
-    deduplicateMessages(options.messages); // TODO: do better
+    deduplicateMessages( options.messages ); // TODO: do better
   return compiled;
 }
 
@@ -478,12 +479,11 @@ function compileDoX( model ) {
   resolve( model );
   tweakAssocs( model );
   assertConsistency( model );
+  check( model );
   throwWithError();
   if (options.lintMode)
     return model;
 
-  check(model);
-  throwWithError();
   return propagator.propagate( model );
 }
 
@@ -498,7 +498,7 @@ function compileDoX( model ) {
  * not normalized - any strings work
  */
 async function processFilenames( filenames, dir ) {
-  const filenameMap = Object.create(null);
+  const filenameMap = Object.create( null );
 
   const promises = [];
   for (const originalName of filenames) {
@@ -508,12 +508,12 @@ async function processFilenames( filenames, dir ) {
     // Resolve possible symbolic link; if the file does not exist
     // we just continue using the original name because readFile()
     // already handles non-existent files.
-    const promise = fs.promises.realpath(path.resolve(dir, originalName))
-      .then(setName, () => setName(originalName));
-    promises.push(promise);
+    const promise = fs.promises.realpath( path.resolve( dir, originalName ) )
+      .then( setName, () => setName( originalName ) );
+    promises.push( promise );
   }
 
-  await Promise.all(promises);
+  await Promise.all( promises );
   return createSourcesDict( filenames, filenameMap, dir );
 }
 
@@ -521,15 +521,15 @@ async function processFilenames( filenames, dir ) {
  * Synchronous version of processFilenames().
  */
 function processFilenamesSync( filenames, dir ) {
-  const filenameMap = Object.create(null);
+  const filenameMap = Object.create( null );
 
   for (const originalName of filenames) {
-    let name = path.resolve(dir, originalName);
+    let name = path.resolve( dir, originalName );
     try {
       // Resolve possible symbolic link; if the file does not exist
       // we just continue using the original name because readFile()
       // already handles non-existent files.
-      name = fs.realpathSync.native(name);
+      name = fs.realpathSync.native( name );
     }
     catch (e) {
       // Ignore the not-found (ENOENT) error
@@ -551,7 +551,7 @@ function processFilenamesSync( filenames, dir ) {
  * @return {{sources: object, files: string[], repeated: ArgumentError[]}}
  */
 function createSourcesDict( filenames, filenameMap, dir ) {
-  const sources = Object.create(null);
+  const sources = Object.create( null );
   const files = [];
   const repeated = [];
 
@@ -559,7 +559,7 @@ function createSourcesDict( filenames, filenameMap, dir ) {
     const name = filenameMap[originalName];
     if (!sources[name]) {
       sources[name] = path.relative( dir, name );
-      files.push(name);
+      files.push( name );
     }
     else if (typeof sources[name] === 'string') { // not specified more than twice
       const msg = `Repeated argument: file '${ sources[name] }'`;