@sap/cds-compiler 3.4.2 → 3.4.4

package/lib/render/utils/common.js

@@ -72,7 +72,6 @@ function beautifyExprArray(tokens) {
   return result;
 }
 
-
 /**
  * Get the part that is really the name of this artifact and not just prefix caused by a context/service
  *
@@ -86,7 +85,6 @@ function getRealName(csn, artifactName) {
   if (parts.length === 1)
     return artifactName;
 
-
   const namespace = getNamespace(csn, artifactName);
   const startIndex = namespace ? namespace.split('.').length : 0;
   let indexOfLastParent = startIndex;
@@ -129,7 +127,6 @@ function getParentContextName(csn, artifactName) {
     if (art && (art.kind === 'context' || art.kind === 'service'))
       return name;
   }
-
   return null;
 }
 
@@ -404,8 +401,7 @@ function getSqlSnippets(options, obj) {
  *
  * @callback renderPart
  * @param {object|array} expression
- * @param {CdlRenderEnvironment} env
- * @this {{inline: Boolean, nestedExpr: Boolean}}
+ * @this {ExpressionRenderer}
  * @returns {string}
  */
 
@@ -415,7 +411,27 @@ function getSqlSnippets(options, obj) {
  *
  * @typedef {object} ExpressionConfiguration
  * @property {(x: any) => string} finalize The final function to call on the expression(-string) before returning
- * @property {renderPart} explicitTypeCast
+ * @property {renderPart} typeCast
+ * @property {renderPart} val
+ * @property {renderPart} enum
+ * @property {renderPart} ref
+ * @property {renderPart} aliasOnly
+ * @property {renderPart} windowFunction
+ * @property {renderPart} func
+ * @property {renderPart} xpr
+ * @property {renderPart} SELECT
+ * @property {renderPart} SET
+ * @property {Function} [visitExpr]
+ * @property {Function} [renderExpr]
+ * @property {Function} [renderSubExpr]
+ * @property {boolean} [isNestedXpr]
+ * @property {CdlRenderEnvironment} [env]
+ */
+
+/**
+ * @typedef {object} ExpressionRenderer
+ * @property {(x: any) => string} finalize The final function to call on the expression(-string) before returning
+ * @property {renderPart} typeCast
  * @property {renderPart} val
  * @property {renderPart} enum
  * @property {renderPart} ref
@@ -425,94 +441,128 @@ function getSqlSnippets(options, obj) {
  * @property {renderPart} xpr
  * @property {renderPart} SELECT
  * @property {renderPart} SET
- * @property {boolean} [inline]
- * @property {boolean} [nestedExpr]
+ * @property {Function} visitExpr
+ * @property {Function} renderExpr
+ * @property {Function} renderSubExpr
+ * @property {boolean} isNestedXpr
+ * @property {CdlRenderEnvironment} env
  */
 
+/**
+ * If `xpr` has a `cast` property, return a copy without it, otherwise return `xpr`.
+ * Useful for removing e.g. top-level CDL-style casts that should not be rendered as CAST().
+ *
+ * @param xpr
+ */
+function withoutCast(xpr) {
+  return !xpr.cast ? xpr : { ...xpr, cast: undefined };
+}
+
 /**
  * Render an expression (including paths and values) or condition 'x'.
  * (no trailing LF, don't indent if inline)
  *
- * @param {ExpressionConfiguration} renderer
- * @returns {Function} Rendered expression
+ * @param {ExpressionConfiguration} rendererBase
+ * @returns {ExpressionRenderer} Expression rendering utility
  */
-function getExpressionRenderer(renderer) {
+function createExpressionRenderer(rendererBase) {
+  const renderer = Object.create(rendererBase);
+  renderer.visitExpr = visitExpr;
   /**
-   * Render an expression (including paths and values) or condition 'x'.
-   * (no trailing LF, don't indent if inline)
-   *
-   * @todo Reuse this with toCdl
-   * @param {Array|object|string} expr Expression to render
-   * @param {object} env Render environment
-   * @param {boolean} [inline=true] Whether to render the expression inline
-   * @param {boolean} [nestedExpr=false] Whether to treat the expression as nested
-   * @param {boolean} [alwaysRenderCast=false] Whether to _always_ render SQL-style casts, even if `nestedExpr === false`.
-   *                                           Note: This is a hack for casts() inside groupBy.
-   * @returns {string} Rendered expression
+   * @param {any} x
+   * @param {CdlRenderEnvironment} env
    */
-  return function renderExpr(expr, env, inline = true, nestedExpr = false, alwaysRenderCast = false) {
-  // Compound expression
-    if (Array.isArray(expr)) {
-      const tokens = expr.map(item => renderExpr(item, env, inline, nestedExpr));
-      return beautifyExprArray(tokens);
-    }
-    else if (typeof expr === 'object' && expr !== null) {
-      if ((nestedExpr || alwaysRenderCast) && expr.cast && expr.cast.type && !expr.cast.target)
-        return renderer.explicitTypeCast.call({ inline, nestedExpr }, expr, env);
-      return renderExprObject(expr);
-    }
+  renderer.renderExpr = function renderExpr(x, env) {
+    /** @type {ExpressionRenderer} */
+    const renderObj = Object.create(renderer);
+    renderObj.env = env || this?.env;
+    // The outermost expression is not nested. All `.xpr` inside `expr`
+    // are nested.  This information is used for adding parentheses around
+    // expressions (see `this.xpr()`).
+    renderObj.isNestedXpr = false;
+    return renderObj.visitExpr(x);
+  };
+  /**
+   * @param {any} x
+   * @param {CdlRenderEnvironment} env
+   */
+  renderer.renderSubExpr = function renderSubExpr(x, env) {
+    /** @type {ExpressionRenderer} */
+    const renderObj = Object.create(renderer);
+    renderObj.env = env || this?.env;
+    renderObj.isNestedXpr = true;
+    return renderObj.visitExpr(x);
+  };
+
+  return renderer;
+}
+
+
+/**
+ * Render an expression (including paths and values) or condition 'x'.
+ * (no trailing LF, don't indent if inline)
+ *
+ * `this` must refer to an object of type `ExpressionRenderer`, see
+ * `createExpressionRenderer()`
+ *
+ * @param {any} x (Sub-)Expression to render
+ *
+ * @this ExpressionRenderer
+ * @returns {string} Rendered expression
+ */
+function visitExpr(x) {
+  if (Array.isArray(x)) {
+    // Compound expression, e.g. for on- or where-conditions.
+    // If xpr is part of an array, it's always a nested xpr,
+    // e.g. CSN for `(1=1 or 2=2) and 3=3`.
+    const tokens = x.map(item => this.renderSubExpr(item));
+    return beautifyExprArray(tokens);
+  }
+  else if (typeof x !== 'object' || x === null) {
     // Not a literal value but part of an operator, function etc - just leave as it is
-    // FIXME: For the sake of simplicity, we should get away from all this uppercasing in toSql
-    return renderer.finalize.call({ inline, nestedExpr }, expr, env);
-
-
-    /**
-     * Various special cases represented as objects
-     *
-     * @param {object} x Expression
-     * @returns {string} String representation of the expression
-     */
-    function renderExprObject(x) {
-      if (x.list) { // TODO: Does this still exist?
-        return `(${x.list.map(item => renderExpr(item, env, inline, false)).join(', ')})`;
-      }
-      else if (x.val !== undefined) {
-        return renderer.val.call({ inline, nestedExpr }, x, env);
-      }
-      // Enum symbol
-      else if (x['#']) {
-        return renderer.enum.call({ inline, nestedExpr }, x, env);
-      }
-      // Reference: Array of path steps, possibly preceded by ':'
-      else if (x.ref) {
-        return renderer.ref.call({ inline, nestedExpr }, x, env);
-      }
-      // Function call, possibly with args (use '=>' for named args)
-      else if (x.func) {
-        if (x.xpr)
-          return renderer.windowFunction.call({ inline, nestedExpr }, x, env);
-        return renderer.func.call({ inline, nestedExpr }, x, env);
-      }
-      // Nested expression
-      else if (x.xpr) {
-        return renderer.xpr.call({ inline, nestedExpr }, x, env);
-      }
-      // Sub-select
-      else if (x.SELECT) {
-        return renderer.SELECT.call({ inline, nestedExpr }, x, env);
-      }
-      else if (x.SET) {
-        return renderer.SET.call({ inline, nestedExpr }, x, env);
-      }
-      else if (x.as && x.cast && x.cast.type && x.cast.target) {
-        return renderer.aliasOnly.call({ inline, nestedExpr }, x, env);
-      }
+    return this.finalize(x);
+  }
+  else if (x.cast?.type && !x.cast.target) {
+    return this.typeCast(x);
+  }
+  else if (x.list) {
+    // Render as non-nested expr.
+    return `(${x.list.map(item => this.renderExpr(item)).join(', ')})`;
+  }
+  else if (x.val !== undefined) {
+    return this.val(x);
+  }
+  else if (x['#']) {
+    // Enum symbol
+    return this.enum(x);
+  }
+  else if (x.ref) {
+    // Reference: Array of path steps, possibly preceded by ':'
+    return this.ref(x);
+  }
+  else if (x.func) {
+    // Function call, possibly with args (use '=>' for named args)
+    if (x.xpr)
+      return this.windowFunction(x);
+    return this.func(x);
+  }
+  else if (x.xpr) {
+    return this.xpr(x);
+  }
+  else if (x.SELECT) {
+    return this.SELECT(x);
+  }
+  else if (x.SET) {
+    return this.SET(x);
+  }
+  else if (x.as) {
+    return this.aliasOnly(x);
+  }
 
-      throw new ModelError(`Unknown expression: ${JSON.stringify(x)}`);
-    }
-  };
+  throw new ModelError(`renderExpr(): Unknown expression: ${JSON.stringify(x)}`);
 }
 
+
 /**
  * @typedef CdlRenderEnvironment Rendering environment used throughout the render process.
  *
@@ -531,8 +581,7 @@ function getExpressionRenderer(renderer) {
 
 module.exports = {
   renderFunc,
-  getExpressionRenderer,
-  beautifyExprArray,
+  createExpressionRenderer,
   getNamespace,
   getRealName,
   addIntermediateContexts,
@@ -544,4 +593,5 @@ module.exports = {
   findElement,
   funcWithoutParen,
   getSqlSnippets,
+  withoutCast,
 };

package/lib/render/utils/delta.js

@@ -0,0 +1,227 @@
+'use strict';
+
+/**
+ * Encapsulate all the functions needed to render SQL ALTER/DROP/ADD statements.
+ */
+class DeltaRenderer {
+  constructor(options, scopedFunctions) {
+    this.options = options;
+    this.scopedFunctions = scopedFunctions;
+  }
+
+  /**
+   * Render column additions as SQL. Checks for duplicate elements.
+   */
+  addColumnsFromElementStrings(artifactName, eltStrings) {
+    return eltStrings.map(eltString => `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ADD ${eltString};`);
+  }
+
+  /**
+   * Render column additions as SQL. Checks for duplicate elements.
+   */
+  addColumnsFromElementsObj(artifactName, elementsObj, env, duplicateChecker) {
+    // Only extend with 'ADD' for elements/associations
+    // TODO: May also include 'RENAME' at a later stage
+    const alterEnv = this.scopedFunctions.activateAlterMode(env);
+    const elements = Object.entries(elementsObj)
+      .map(([ name, elt ]) => this.scopedFunctions.renderElement(artifactName, name, elt, duplicateChecker, null, alterEnv))
+      .filter(s => s !== '');
+
+    if (elements.length)
+      return this.addColumnsFromElementStrings(artifactName, elements);
+
+    return [];
+  }
+
+  /**
+   * By default, we don't support rendering association-alters - only for HANA
+   */
+  addAssociations() {
+    return [];
+  }
+
+  /**
+   * Render key addition as SQL.
+   */
+  addKey(artifactName, elementsObj) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ADD ${this.primaryKey(elementsObj)};` ];
+  }
+
+  /**
+   * Render column removals as SQL.
+   */
+  dropColumns(artifactName, sqlIds) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} DROP ${sqlIds.join(', ')};` ];
+  }
+
+  /**
+   * No associations by default - only for HANA.
+   */
+  dropAssociation() {
+    return [];
+  }
+
+  /**
+   * Render primary-key removals as SQL.
+   */
+  dropKey(artifactName) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} DROP PRIMARY KEY;` ];
+  }
+
+  /**
+   * Render column modifications as SQL.
+   */
+  alterColumns(artifactName, columnName, delta, definitionsStr) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER (${definitionsStr});` ];
+  }
+
+  /**
+   * Render primary keys as SQL.
+   */
+  primaryKey(elementsObj) {
+    const primaryKeys = Object.keys(elementsObj)
+      .filter(name => elementsObj[name].key && !elementsObj[name].virtual)
+      .map(name => this.scopedFunctions.quoteSqlId(name))
+      .join(', ');
+    return primaryKeys && `PRIMARY KEY(${primaryKeys})`;
+  }
+
+  /**
+   * Render entity-comment modifications as SQL.
+   */
+  alterEntityComment(artifactName, comment) {
+    return [ `COMMENT ON TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} IS ${this.comment(comment)};` ];
+  }
+
+  /**
+   * Render column-comment modifications as SQL.
+   */
+  alterColumnComment(artifactName, columnName, comment) {
+    return [ `COMMENT ON COLUMN ${this.scopedFunctions.renderArtifactName(artifactName)}.${columnName} IS ${this.comment(comment)};` ];
+  }
+
+  /**
+   * Render comment string.
+   */
+  comment(comment) {
+    return comment && this.scopedFunctions.renderStringForSql(this.scopedFunctions.getHanaComment({ doc: comment }), this.options.sqlDialect) || 'NULL';
+  }
+
+  /**
+   * Alter SQL snippet for entity.
+   */
+  alterEntitySqlSnippet(artifactName, snippet) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ${snippet};` ];
+  }
+
+  /**
+   * Concatenate multiple statements which are to be treated as one by the API caller.
+   */
+  concat(...statements) {
+    return [ statements.join('\n') ];
+  }
+}
+
+class DeltaRendererHana extends DeltaRenderer {
+  /**
+   * Render column additions as HANA SQL. Checks for duplicate elements.
+   */
+  addColumnsFromElementStrings(artifactName, eltStrings) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ADD (${eltStrings.join(', ')});` ];
+  }
+
+  /**
+   * Render association additions as HANA SQL.
+   * TODO duplicity check
+   */
+  addAssociations(artifactName, elementsObj, env) {
+    return Object.entries(elementsObj)
+      .map(([ name, elt ]) => this.scopedFunctions.renderAssociationElement(name, elt, env))
+      .filter(s => s !== '')
+      .map(eltStr => `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ADD ASSOCIATION (${eltStr});`);
+  }
+
+  /**
+   * Render column removals as HANA SQL.
+   */
+  dropColumns(artifactName, sqlIds) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} DROP (${sqlIds.join(', ')});` ];
+  }
+
+  /**
+   * Render association removals as HANA SQL.
+   */
+  dropAssociation(artifactName, sqlId) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} DROP ASSOCIATION ${sqlId};` ];
+  }
+}
+
+class DeltaRendererPostgres extends DeltaRenderer {
+  /**
+   * Render primary-key removals as SQL.
+   * @todo tableName is escaped - we cannot simply add _pkey
+   */
+  dropKey(artifactName) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} DROP CONSTRAINT ${this.scopedFunctions.renderArtifactName(`${artifactName}_pkey`)};` ];
+  }
+
+  /**
+   * Render column removals as SQL.
+   */
+  dropColumns(artifactName, sqlIds) {
+    return sqlIds.map(sqlId => `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} DROP ${sqlId};`);
+  }
+
+  /**
+   * Render column modifications as Postgres SQL - no ( ), special NOT NULL.
+   */
+  alterColumns(artifactName, columnName, delta, definitionsStr) {
+    const sqls = [];
+    if (delta.new.notNull === true || delta.new.key === true)
+      definitionsStr = definitionsStr.replace(' NOT NULL', ''); // TODO: Is this robust enough?
+    else if (delta.new.notNull === false || delta.new.$notNull === false)
+      definitionsStr = definitionsStr.replace(' NULL', ''); // TODO: Is this robust enough?
+
+    sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${definitionsStr};`);
+    if (delta.new.notNull && !delta.old.notNull)
+      sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${columnName} SET NOT NULL;`);
+    else if (delta.old.notNull && !delta.new.notNull)
+      sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${columnName} DROP NOT NULL;`);
+
+    return sqls;
+  }
+}
+
+class DeltaRendererH2 extends DeltaRenderer {
+  /**
+   * Render column modifications as H2 SQL - no ().
+   */
+  alterColumns(artifactName, columnName, delta, definitionsStr) {
+    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${definitionsStr};` ];
+  }
+}
+
+/**
+ * Return an object encapsulating the render-functions for ALTER/DROP for a given db dialect.
+ *
+ * @param {CSN.Options} options
+ * @param {object} scopedFunctions
+ * @returns {DeltaRenderer}
+ */
+function getDeltaRenderer(options, scopedFunctions) {
+  switch (options.sqlDialect) {
+    case 'hana':
+      return new DeltaRendererHana(options, scopedFunctions);
+    case 'h2':
+      return new DeltaRendererH2(options, scopedFunctions);
+    case 'postgres':
+      return new DeltaRendererPostgres(options, scopedFunctions);
+    default:
+      return new DeltaRenderer(options, scopedFunctions);
+  }
+}
+
+
+module.exports = {
+  getDeltaRenderer,
+};

package/lib/transform/db/.eslintrc.json

@@ -10,6 +10,8 @@
     "template-curly-spacing":["error", "never"],
     "complexity": ["warn", 40],
     "max-len": "off",
+    // there seem to be false positives
+    "jsdoc/require-returns-check": "off",
     // Don't enforce stupid descriptions
     "jsdoc/require-param-description": "off",
     "jsdoc/require-returns-description": "off",

package/lib/transform/draft/.eslintrc.json

@@ -1,38 +1,4 @@
 {
   "root": true,
-  "plugins": ["sonarjs", "jsdoc"],
-  "extends": ["../../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended", "plugin:jsdoc/recommended"],
-  "rules": {
-    "prefer-const": "error",
-    "quotes": ["error", "single", "avoid-escape"],
-    "prefer-template": "error",
-    "no-trailing-spaces": "error",
-    "template-curly-spacing":["error", "never"],
-    "complexity": ["warn", 30],
-    "max-len": "off",
-    // Don't enforce stupid descriptions
-    "jsdoc/require-param-description": "off",
-    "jsdoc/require-returns-description": "off",
-    // Sometimes if-else's are more specific
-    "sonarjs/prefer-single-boolean-return": "off",
-    // Very whiny and nitpicky
-    "sonarjs/cognitive-complexity": "off",
-    // Does not recognize TS types
-    "jsdoc/no-undefined-types": "off",
-    // Whiny and annoying
-    "sonarjs/no-duplicate-string": "off"
-  },
-  "parserOptions": {
-    "ecmaVersion": 2020,
-    "sourceType": "script"
-  },
-  "env": {
-    "es2020": true,
-    "node": true
-  },
-  "settings": {
-    "jsdoc": {
-      "mode": "typescript"
-    }
-  }
+  "extends": ["../db/.eslintrc.json"]
 }

package/lib/transform/forOdataNew.js

@@ -213,14 +213,14 @@ function transform4odataWithCsn(inputModel, options) {
   const skipPersNameKinds = {'service':1, 'context':1, 'namespace':1, 'annotation':1, 'action':1, 'function':1};
   forEachDefinition(csn, (def, defName) => {
     // Resolve annotation shorthands for entities, types, annotations, ...
-    renameShorthandAnnotations(def);
+    renameShorthandAnnotations(def, ['definitions', defName ]);
 
     // Annotate artifacts with their DB names if requested.
     // Skip artifacts that have no DB equivalent anyway
     if (options.sqlMapping && !(def.kind in skipPersNameKinds))
       def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.sqlMapping, csn, 'hana'); // hana to allow naming mode "hdbcds"
 
-    forEachMemberRecursively(def, (member, memberName, propertyName) => {
+    forEachMemberRecursively(def, (member, memberName, propertyName, path) => {
       // Annotate elements, foreign keys, parameters, etc. with their DB names if requested
       // Only these are actually required and don't annotate virtual elements in entities or types
       // as they have no DB representation (although in views)
@@ -233,7 +233,7 @@ function transform4odataWithCsn(inputModel, options) {
       annotateCoreComputed(member);
 
       // Resolve annotation shorthands for elements, actions, action parameters
-      renameShorthandAnnotations(member);
+      renameShorthandAnnotations(member, path);
 
       // - If the association target is annotated with @cds.odata.valuelist, annotate the
       //      association with @Common.ValueList.viaAssociation
@@ -298,7 +298,7 @@ function transform4odataWithCsn(inputModel, options) {
 
   // Rename shorthand annotations within artifact or element 'node' according to a builtin
   // list.
-  function renameShorthandAnnotations(node) {
+  function renameShorthandAnnotations(node, path) {
     // FIXME: Verify this list - are they all still required? Do we need any more?
     const mappings = {
       '@label': '@Common.Label',
@@ -368,22 +368,29 @@ function transform4odataWithCsn(inputModel, options) {
           if(!node.enum && node.type && !isBuiltinType(node.type))
             typeDef = csn.definitions[node.type];
           if(typeDef.enum) {
-            let enumValue = Object.keys(typeDef.enum).map(enumSymbol => {
+            const enumValue = [];
+            for(const enumSymbol in typeDef.enum) {
               const enumSymbolDef = typeDef.enum[enumSymbol];
-              let result = { '@Core.SymbolicName': enumSymbol };
-              if (enumSymbolDef.val !== undefined)
-                result.Value = enumSymbolDef.val;
-              else if (node.type && node.type === 'cds.String')
-              // the symbol is used as value only for type 'cds.String'
-                result.Value = enumSymbol;
-            // Can't rely that @description has already been renamed to @Core.Description
-            // Eval description according to precedence (doc comment must be considered already in Odata transformer
-            // as in contrast to the other doc commments as it is used to annotate the @Validation.AllowedValues)
-              const desc = enumSymbolDef['@Core.Description'] || enumSymbolDef['@description'] || enumSymbolDef.doc;
-              if (desc)
-                result['@Core.Description'] = desc;
-              return result;
-            });
+              if(enumSymbolDef.val === null)
+                info('odata-enum-value-type', path,
+                  {name: enumSymbol, value: null, anno: '@Valiation.AllowedValues' },
+                  'Value $(VALUE) for enum element $(NAME) not added to $(ANNO)');
+              else {
+                const result = { '@Core.SymbolicName': enumSymbol };
+                if (enumSymbolDef.val !== undefined)
+                  result.Value = enumSymbolDef.val;
+                else if (node.type && node.type === 'cds.String')
+                  // the symbol is used as value only for type 'cds.String'
+                  result.Value = enumSymbol;
+                // Can't rely that @description has already been renamed to @Core.Description
+                // Eval description according to precedence (doc comment must be considered already in Odata transformer
+                // as in contrast to the other doc commments as it is used to annotate the @Validation.AllowedValues)
+                const desc = enumSymbolDef['@Core.Description'] || enumSymbolDef['@description'] || enumSymbolDef.doc;
+                if (desc)
+                  result['@Core.Description'] = desc;
+                enumValue.push(result);
+              }
+            }
             setAnnotation(node, '@Validation.AllowedValues', enumValue);
           }
         }