@sap/cds-compiler 3.3.2 → 3.4.2

package/lib/language/multiLineStringParser.js

@@ -25,9 +25,9 @@ const {
  *                             of whitespace characters removed.
  */
 function stripIndentation(str) {
-  if (str === '') {
-    return ['', 0];
-  }
+  if (str === '')
+    return [ '', 0 ];
+
 
   // Note: We have to check all newline characters, as the string is not normalized, yet.
   const lines = str.split(cdlNewLineRegEx);
@@ -39,20 +39,19 @@ function stripIndentation(str) {
     // If there is a trailing line break, it means that ``` is on newline and
     // therefore the indentation to remove is 0.
     // Remove the last newline, which may be CRLF.
-    return [lines.slice(0, -1).join('\n'), 0];
+    return [ lines.slice(0, -1).join('\n'), 0 ];
   }
 
   const minIndent = lines.reduce((min, line, index) => {
     // Note: Last line is the line containing ```.  There, we always count the indentation,
     //       even if blank.  For all other lines, blank lines are ignored.
-    if (isWhitespaceOrNewLineOnly(line) && index !== (n-1))
+    if (isWhitespaceOrNewLineOnly(line) && index !== (n - 1))
       return min;
 
     let count = 0;
     const length = Math.min(min, line.length);
-    while (count < length && isWhitespaceCharacterNoNewline(line[count])) {
+    while (count < length && isWhitespaceCharacterNoNewline(line[count]))
       count++;
-    }
     return Math.min(min, count);
   }, Number.MAX_SAFE_INTEGER);
 
@@ -63,10 +62,10 @@ function stripIndentation(str) {
   }
 
   // Remove trailing last line, if there was nothing else in that line.
-  if (lines[n-1] === '')
+  if (lines[n - 1] === '')
     lines.pop();
 
-  return [lines.join('\n'), minIndent];
+  return [ lines.join('\n'), minIndent ];
 }
 
 class MultiLineStringParser {
@@ -75,9 +74,9 @@ class MultiLineStringParser {
     this.token = token;
     this.str = token.text; // Copy because .text is a getter
 
-    if (this.str[0] !== '`' || this.str[this.str.length-1] !== '`') {
+    if (this.str[0] !== '`' || this.str[this.str.length - 1] !== '`')
+      // eslint-disable-next-line max-len
       throw new Error('Invalid multi-line string sequence: Require string to be surrounded by back-ticks!');
-    }
 
     this.output = [];
     this.isTextBlock = this.str.startsWith('```');
@@ -90,7 +89,8 @@ class MultiLineStringParser {
     if (this.isTextBlock) {
       this.i = 3;
       this.end = this.str.length - 3;
-    } else {
+    }
+    else {
       this.i = 1;
       this.end = this.str.length - 1;
     }
@@ -102,9 +102,8 @@ class MultiLineStringParser {
    * @return {string}
    */
   parse() {
-    if (this.str.length === 2) {
+    if (this.str.length === 2)
       return ''; // Nothing to do: ``
-    }
 
     if (this.isTextBlock) {
       // If there are no line breaks, emit an error as normal single-back-tick
@@ -112,7 +111,7 @@ class MultiLineStringParser {
       // there is no text without at least one line break.
       if (!cdlNewLineRegEx.test(this.str)) {
         const loc = this._locationForCharacters(this.end, 1);
-        this.parser.message('syntax-invalid-text-block', loc);
+        this.parser.error('syntax-invalid-text-block', loc);
         return '';
       }
       this._skipOptionalLanguageIdentifierLine();
@@ -135,7 +134,7 @@ class MultiLineStringParser {
     // Note: Index is at first character of string
 
     do {
-      switch(this._current()) {
+      switch (this._current()) {
         case this._matchLineBreakAtCurrentChar():
           this.output.push('\n');
           break;
@@ -146,8 +145,8 @@ class MultiLineStringParser {
         case '$':
           if (this._lookahead() === '{') {
             const loc = this._locationForCharacters(this.i, 2);
-            this.parser.message('syntax-missing-escape', loc,
-              { '#': 'placeholder', code: '${', newcode: '\\${' });
+            this.parser.error('syntax-missing-escape', loc,
+                              { '#': 'placeholder', code: '${', newcode: '\\${' });
           }
           this.output.push(this.str[this.i]);
           break;
@@ -155,7 +154,7 @@ class MultiLineStringParser {
           this.output.push(this.str[this.i]);
           break;
       }
-    } while(this._move());
+    } while (this._move());
 
     return this.output.join('');
   }
@@ -166,27 +165,27 @@ class MultiLineStringParser {
    * @private
    */
   _innerEscape() {
-    switch(this._current()) {
+    switch (this._current()) {
       case this._matchLineBreakAtCurrentChar():
         // Don't add to output -> line break is escaped
         break;
       case 'b': // backspace
-        this.output.push(`\b`);
+        this.output.push('\b');
         break;
       case 'f': // form feed
-        this.output.push(`\f`);
+        this.output.push('\f');
         break;
       case 'v': // vertical tabulator
-        this.output.push(`\v`);
+        this.output.push('\v');
         break;
       case 'r': // carriage return
-        this.output.push(`\r`);
+        this.output.push('\r');
         break;
       case 'n': // line feed
-        this.output.push(`\n`);
+        this.output.push('\n');
         break;
       case 't': // tab
-        this.output.push(`\t`);
+        this.output.push('\t');
         break;
       case '\\':
       case '"':
@@ -206,21 +205,23 @@ class MultiLineStringParser {
         break;
       case '0': // null terminator
         if (!/^\d$/.test(this._lookahead())) {
-          this.output.push(`\0`);
+          this.output.push('\0');
           break;
         }
         // Let the default case handle octal representation.
         // fallthrough
       default: {
         this.output.push(this._current());
-        const loc = this._locationForCharacters(this.i-1, 2);
+        const loc = this._locationForCharacters(this.i - 1, 2);
         if (/\s/.test(this._current())) {
-          this.parser.message('syntax-invalid-escape', loc, { '#': 'whitespace' });
-        } else if (/\d/.test(this._current())) {
-          this.parser.message('syntax-invalid-escape', loc, { '#': 'octal' });
-        } else {
-          const code = this._makeCode('\\' + this._current());
-          this.parser.message('syntax-unknown-escape', loc,  { '#': 'std', code });
+          this.parser.error('syntax-invalid-escape', loc, { '#': 'whitespace' });
+        }
+        else if (/\d/.test(this._current())) {
+          this.parser.error('syntax-invalid-escape', loc, { '#': 'octal' });
+        }
+        else {
+          const code = this._makeCode(`\\${ this._current() }`);
+          this.parser.message('syntax-unknown-escape', loc, { '#': 'std', code });
         }
         break;
       }
@@ -239,9 +240,9 @@ class MultiLineStringParser {
     // syntax variant as the first invalid code point is \u{110000}
     // and an empty `codePoint` is only possible with the braced variant.
     const reportInvalidCodePoint = () => {
-      const code = this._makeCode(`\\u{${codePoint}}`);
-      const loc = this._locationForCharacters(this.i-codePoint.length, codePoint.length);
-      this.parser.message('syntax-invalid-escape', loc, { '#': 'codepoint', code });
+      const code = this._makeCode(`\\u{${ codePoint }}`);
+      const loc = this._locationForCharacters(this.i - codePoint.length, codePoint.length);
+      this.parser.error('syntax-invalid-escape', loc, { '#': 'codepoint', code });
     };
 
     const n = Number.parseInt(codePoint, 16);
@@ -252,7 +253,8 @@ class MultiLineStringParser {
 
     try {
       this.output.push(String.fromCodePoint(n));
-    } catch (e) {
+    }
+    catch (e) {
       // RangeError is thrown if number isn't a valid code point
       reportInvalidCodePoint();
     }
@@ -275,18 +277,20 @@ class MultiLineStringParser {
       if (!this._eos() && /^[\dA-Fa-f]$/.test(this._lookahead())) {
         this._move();
         codePoint += this._current();
-      } else {
+      }
+      else {
         break;
       }
     }
 
     if (codePoint.length === count) {
       this._parseHexCodePoint(codePoint);
-    } else {
-      const loc = this._locationForCharacters(this.i+1, 1);
-      const code = this._eos(this.i+1) ? `\\${mode}${codePoint}` : `\\${mode}${codePoint}${this._lookahead()}`;
-      this.parser.message('syntax-invalid-escape', loc,
-        { '#': 'hex-count', number: count, code: this._makeCode(code) });
+    }
+    else {
+      const loc = this._locationForCharacters(this.i + 1, 1);
+      const code = this._eos(this.i + 1) ? `\\${ mode }${ codePoint }` : `\\${ mode }${ codePoint }${ this._lookahead() }`;
+      this.parser.error('syntax-invalid-escape', loc,
+                        { '#': 'hex-count', number: count, code: this._makeCode(code) });
     }
   }
 
@@ -305,14 +309,17 @@ class MultiLineStringParser {
       if (/^[\dA-Fa-f]$/.test(this._lookahead())) {
         this._move();
         codePoint += this._current();
-      } else if (this._lookahead() === '}') {
+      }
+      else if (this._lookahead() === '}') {
         break;
-      } else if (!this._eos(this.i+1)) {
-        const loc = this._locationForCharacters(this.i+1, 1); // Point to the exact character
-        const code = this._makeCode(`\\u{${codePoint}${this._lookahead()}…}`);
-        this.parser.message('syntax-invalid-escape', loc, { '#': 'unicode-hex', code });
+      }
+      else if (!this._eos(this.i + 1)) {
+        const loc = this._locationForCharacters(this.i + 1, 1); // Point to the exact character
+        const code = this._makeCode(`\\u{${ codePoint }${ this._lookahead() }…}`);
+        this.parser.error('syntax-invalid-escape', loc, { '#': 'unicode-hex', code });
         return;
-      } else {
+      }
+      else {
         break;
       }
     }
@@ -320,9 +327,10 @@ class MultiLineStringParser {
     if (this._lookahead() === '}') {
       this._move();
       this._parseHexCodePoint(codePoint);
-    } else {
+    }
+    else {
       const loc = this._locationForCharacters(this.i, 1);
-      this.parser.message('syntax-invalid-escape', loc, { '#': 'unicode-brace' });
+      this.parser.error('syntax-invalid-escape', loc, { '#': 'unicode-brace' });
     }
   }
 
@@ -333,7 +341,7 @@ class MultiLineStringParser {
    * @private
    */
   _skipOptionalLanguageIdentifierLine() {
-    while(!this._eos()) {
+    while (!this._eos()) {
       switch (this._current()) {
         case this._matchLineBreakAtCurrentChar():
           this._move();
@@ -342,7 +350,7 @@ class MultiLineStringParser {
           // Do not allow an escape in the language identifier. If at the line's end, users
           // may expect the identifier to span more than the first line, which is _not_ the case.
           const loc = this._locationForCharacters(this.i, 1);
-          this.parser.message('syntax-invalid-escape', loc, { '#': 'language-identifier' });
+          this.parser.error('syntax-invalid-escape', loc, { '#': 'language-identifier' });
           this._move();
           break;
         }
@@ -367,7 +375,7 @@ class MultiLineStringParser {
    */
   _matchLineBreakAtCurrentChar() {
     // Only increase line number for \n, because ANTLR does the same
-    switch(this._current()) {
+    switch (this._current()) {
       case '\r':
         if (this._lookahead() === '\n') {
           this._move(); // \r\n is normalized
@@ -382,6 +390,7 @@ class MultiLineStringParser {
       case '\u2028': // LS
       case '\u2029': // PS
         return this._current();
+      default: break;
     }
     return null;
   }
@@ -419,7 +428,7 @@ class MultiLineStringParser {
    * @returns {string}
    */
   _lookahead() {
-    return this.str[this.i+1];
+    return this.str[this.i + 1];
   }
 
   /**
@@ -439,7 +448,7 @@ class MultiLineStringParser {
    * @returns {string}
    */
   _previous() {
-    return this.str[this.i-1];
+    return this.str[this.i - 1];
   }
 
   /**
@@ -455,8 +464,12 @@ class MultiLineStringParser {
       file: this.parser.filename,
       line: this.token.line + this._lineInString,
       endLine: this.token.line + this._lineInString,
-      col: this._lineInString > 0 ? i - this._currentLineBreakIndex + this._indentation : this.token.column + i + 1,
-      endCol: this._lineInString > 0 ? i - this._currentLineBreakIndex + width + this._indentation :  this.token.column + i + width + 1,
+      col: this._lineInString > 0
+        ? i - this._currentLineBreakIndex + this._indentation
+        : this.token.column + i + 1,
+      endCol: this._lineInString > 0
+        ? i - this._currentLineBreakIndex + width + this._indentation
+        : this.token.column + i + width + 1,
     };
   }
 
@@ -468,7 +481,7 @@ class MultiLineStringParser {
    * @param {string} code
    * @private
    */
-  _makeCode(code) {
+  _makeCode(code) { // eslint-disable-line class-methods-use-this
     // For characters that may be rendered as newline,
     // see <https://www.unicode.org/reports/tr14/tr14-32.html>.
     //
@@ -484,9 +497,8 @@ class MultiLineStringParser {
     //
     // For Visualization, see <https://en.wikipedia.org/wiki/Newline#Unicode>
     //   U+23CE: ⏎
-
-    const allPossibleNewLineCharacters = /[\u{000A}\u{000B}\u{000C}\u{000D}\u{0085}\u{2028}\u{2029}]/ug;
-    return code.replace(allPossibleNewLineCharacters, '\u{23CE}');
+    const allNewLineCharacters = /[\u{000A}\u{000B}\u{000C}\u{000D}\u{0085}\u{2028}\u{2029}]/ug;
+    return code.replace(allNewLineCharacters, '\u{23CE}');
   }
 }
 

package/lib/main.js

@@ -115,6 +115,7 @@ module.exports = {
       functions: Object.freeze([ ...keywords.cdl_functions ] ),
     }),
     sql: Object.assign((...args) => snapi.sql(...args), {
+      migration: (...args) => snapi.sql.migration(...args),
       sqlite: {
         keywords: Object.freeze([ ...keywords.sqlite ] )
       },

package/lib/model/csnRefs.js

@@ -924,14 +924,15 @@ function startCsnPath( csnPath, csn ) {
       index: 1, main, parent, art,
     };
   }
-  if (csnPath.length < 2 || csnPath[0] !== 'definitions')
-    throw new CompilerAssertion( 'References outside definitions not supported yet');
-  const art = csn.definitions[csnPath[1]];
+  if (csnPath.length < 2 || csnPath[0] !== 'definitions' && csnPath[0] !== 'vocabularies')
+    throw new CompilerAssertion( 'References outside definitions and vocabularies not supported yet');
+  const art = csn[csnPath[0]][csnPath[1]];
   return {
     index: 2, main: art, parent: null, art,
   };
 }
 
+
 /**
  * @param {CSN.Path} csnPath
  * @param {CSN.Model} csn

package/lib/model/csnUtils.js

@@ -1106,22 +1106,24 @@ const _dependents = Symbol('_dependents');
  * _dependents: All artifacts that depend on this artifact (because they have a ref that points to it)
  * _dependencies: All artifacts this artifact depends on (because it has a ref to it)
  *
- * @param {object} csn A CSN to enrich in-place
+ * @param {CSN.Model} csn A CSN to enrich in-place
+ * @param {object} refs csnRefs, only used for artifactRef
  * @returns {object} CSN with _dependents/_dependencies set, "cleanup" function, _dependents/_dependencies Symbol used
  */
-function setDependencies( csn ) {
+function setDependencies( csn, refs = csnRefs(csn) ) {
   const cleanup = [];
-  const { artifactRef } = csnRefs(csn);
+  const { artifactRef } = refs;
 
   forEachDefinition(csn, (artifact, artifactName) => {
-    if (getNormalizedQuery(artifact).query) {
+    const queries = getNormalizedQuery(artifact).query;
+    if (queries) {
       initDependencies(artifact);
-      forAllQueries(getNormalizedQuery(artifact).query, (query) => {
-        if (query.SELECT && query.SELECT.from) {
+      forAllQueries(queries, (query) => {
+        if (query.SELECT?.from) {
           if (query.SELECT.from.args)
             handleArgs(artifact, artifactName, query.SELECT.from.args);
 
-          else if (typeof query.SELECT.from === 'string' || query.SELECT.from.ref )
+          else if (typeof query.SELECT.from === 'string' || query.SELECT.from.ref)
             handleDependency(artifactRef(query.SELECT.from), artifact, artifactName);
         }
       }, [ 'definitions', artifactName, (artifact.projection ? 'projection' : 'query') ]);
@@ -1172,6 +1174,34 @@ function setDependencies( csn ) {
 function isPersistedOnDatabase(art) {
   return !(art.kind === 'entity' && (art.abstract || hasAnnotationValue(art, '@cds.persistence.skip')));
 }
+/**
+ * Check if the given artifact will be persisted on the database via `CREATE VIEW`
+ *
+ * @param {CSN.Artifact} artifact
+ * @returns {boolean}
+ */
+function isPersistedAsView(artifact) {
+  return artifact && artifact.kind === 'entity' &&
+      !artifact._ignore &&
+      !artifact.abstract &&
+      ((artifact.query || artifact.projection) && !hasAnnotationValue(artifact, '@cds.persistence.table')) &&
+      !hasAnnotationValue(artifact, '@cds.persistence.skip') &&
+      !hasAnnotationValue(artifact, '@cds.persistence.exists');
+}
+/**
+ * Check if the given artifact will be persisted on the database via `CREATE TABLE`
+ *
+ * @param {CSN.Artifact} artifact
+ * @returns {boolean}
+ */
+function isPersistedAsTable(artifact) {
+  return artifact.kind === 'entity' &&
+      !artifact._ignore &&
+      !artifact.abstract &&
+      (!artifact.query && !artifact.projection || hasAnnotationValue(artifact, '@cds.persistence.table')) &&
+      !hasAnnotationValue(artifact, '@cds.persistence.skip') &&
+      !hasAnnotationValue(artifact, '@cds.persistence.exists');
+}
 
 /**
  * Central generated by cds-compiler string generator function without further decoration
@@ -1533,6 +1563,8 @@ module.exports = {
   applyTransformationsOnDictionary,
   setDependencies,
   isPersistedOnDatabase,
+  isPersistedAsView,
+  isPersistedAsTable,
   generatedByCompilerVersion,
   getNormalizedQuery,
   getRootArtifactName,

package/lib/model/sortViews.js

@@ -51,7 +51,7 @@ function _calculateDepth(definitionsArray, _dependents, _dependencies) {
       nonZero.push([ artifactName, artifact ]);
     }
     else {
-      artifact.$pointers = 0;
+      delete artifact.$pointers;
       zero.push([ artifactName, artifact ]);
     }
   });
@@ -66,10 +66,14 @@ function _findWithXPointers(definitionsArray, x, _dependents, _dependencies) {
   const nonZero = [];
 
   definitionsArray.forEach(([ artifactName, artifact ]) => {
-    if (artifact.$pointers !== undefined && artifact.$pointers === x)
+    if (artifact.$pointers !== undefined && artifact.$pointers === x) {
       zero.push([ artifactName, artifact ]);
-    else
+      if (artifact.$pointers === 0)
+        delete artifact.$pointers;
+    }
+    else {
       nonZero.push([ artifactName, artifact ]);
+    }
   });
 
   return {

package/lib/modelCompare/compare.js

@@ -4,9 +4,12 @@ const { makeMessageFunction } = require('../base/messages');
 const {
   forEachDefinition,
   forEachMember,
-  hasAnnotationValue
+  isPersistedAsTable,
+  isPersistedAsView
 } = require('../model/csnUtils');
 const { isBetaEnabled } = require('../base/model');
+// used to mark a view as changed so we know to drop-create it
+const isChanged = Symbol('Marks a view as changed');
 
 /**
  * Compares two models, in HANA-transformed CSN format, to each other.
@@ -14,7 +17,7 @@ const { isBetaEnabled } = require('../base/model');
  * @param beforeModel the before-model
  * @param afterModel the after-model
  * @param {HdiOptions|false} options
- * @returns {object} the sets of deletions, extensions, and migrations of entities necessary to transform the before-model
+ * @returns {ModelDiff} the sets of deletions, extensions, and migrations of entities necessary to transform the before-model
  * to the after-model, together with all the definitions of the after-model
  */
 function compareModels(beforeModel, afterModel, options) {
@@ -46,17 +49,18 @@ function validateCsnVersions(beforeModel, afterModel, options) {
 
   if (!beforeVersionParts || beforeVersionParts.length < 2) {
     const { error, throwWithAnyError } = makeMessageFunction(beforeModel, options, 'modelCompare');
-    error(null, null, {}, `Invalid CSN version: ${beforeVersion}`);
+    error(null, null, { version: beforeVersion }, 'Invalid CSN version: $(VERSION)');
     throwWithAnyError();
   }
   if (!afterVersionParts || afterVersionParts.length < 2) {
     const { error, throwWithAnyError } = makeMessageFunction(afterModel, options, 'modelCompare');
-    error(null, null, {}, `Invalid CSN version: ${afterVersion}`);
+    error(null, null, { version: afterVersion }, 'Invalid CSN version: $(VERSION)');
     throwWithAnyError();
   }
   if (beforeVersionParts[0] > afterVersionParts[0] && !(options && options.allowCsnDowngrade)) {
     const { error, throwWithAnyError } = makeMessageFunction(afterModel, options, 'modelCompare');
-    error(null, null, {}, `Incompatible CSN versions: ${afterVersion} is a major downgrade from ${beforeVersion}. Is @sap/cds-compiler version ${require('../../package.json').version} outdated?`);
+    error(null, null, { value: afterVersion, othervalue: beforeVersion, version: require('../../package.json').version },
+      'Incompatible CSN versions: $(VALUE) is a major downgrade from $(OTHERVALUE). Is @sap/cds-compiler version $(VERSION) outdated?');
     throwWithAnyError();
   }
 }
@@ -116,10 +120,18 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
       // Arguments are interchanged in this case: `artifact` from beforeModel and `otherArtifact` from afterModel.
       if (isPersisted && !isPersistedOther) {
         deletedEntities[name] = artifact;
+      } else if(isPersistedAsView(artifact) && isPersistedOther) { // view turned into table - need to render a drop for the view
+        deletedEntities[name] = artifact;
       }
       return;
     }
 
+    // to make it easier to know which views to drop-create
+    if(isPersistedAsView(artifact) && isPersistedAsView(otherArtifact)) {
+      // TODO: Check only on artifact.query/projection BUT: Need to manually check for sql-snippets then!
+      artifact[isChanged] = JSON.stringify(artifact) !== JSON.stringify(otherArtifact);
+    }
+
     // Looking for added entities and added/deleted/changed elements.
     // Parameters: `artifact` from afterModel and `otherArtifact` from beforeModel.
 
@@ -146,15 +158,6 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
   };
 }
 
-function isPersistedAsTable(artifact) {
-  return artifact.kind === 'entity'
-      && !artifact._ignore
-      && !artifact.abstract
-      && (!artifact.query && !artifact.projection || hasAnnotationValue(artifact, '@cds.persistence.table'))
-      && !hasAnnotationValue(artifact, '@cds.persistence.skip')
-      && !hasAnnotationValue(artifact, '@cds.persistence.exists');
-}
-
 function getElementComparator(otherArtifact, addedElementsDict = null, changedElementsDict = null) {
   return function compareElements(element, name) {
     if (element._ignore) {
@@ -244,5 +247,36 @@ function changedElement(element, otherElement) {
 
 module.exports = {
   compareModels,
-  deepEqual
+  deepEqual,
+  isChanged
 };
+
+/**
+ * A ModelDiff encapsulates the changes between two models ("before" and "after"). It contains information
+ * about changes to .elements and removed artifacts.
+ * 
+ * @typedef {object} ModelDiff
+ * @property {CSN.Definitions} definitions The artifacts present in the "after" model
+ * @property {CSN.Definitions} deletions The artifacts present in the "before", but not in the "after"
+ * @property {extension[]} extensions The elements added to artifacts
+ * @property {migration[]} migrations Altered or removed elements
+ */
+
+/**
+ * @typedef {object} extension
+ * @property {CSN.Elements} elements The elements that where added
+ * @property {string} extend Name of the artifact that the .elements need to be added to
+ */
+
+/**
+ * @typedef {object} migration
+ * @property {Object.<string, ChangeSet>} change An object of changes - the key being the name of the changed element, the value being the change.
+ * @property {string} migrate Name of the artifact that the .change and .remove apply to
+ * @property {CSN.Elements} remove An object of removed elements
+ */
+
+/**
+ * @typedef {object} ChangeSet Describes the change of one element
+ * @property {CSN.Element} old The old element definition
+ * @property {CSN.Element} new The new element definition
+ */