@sap/cds-compiler 3.6.0 → 3.7.2

package/lib/compiler/shared.js

@@ -4,7 +4,6 @@
 'use strict';
 
 const { searchName } = require('../base/messages');
-const { dictAddArray } = require('../base/dictionaries');
 const { isDeprecatedEnabled } = require('../base/model');
 
 const {
@@ -184,7 +183,6 @@ function fns( model ) {
     resolveTypeArgumentsUnchecked,
     resolvePath,
     checkAnnotate,
-    copyAnnotationsForExtensions,
     attachAndEmitValidNames,
   } );
   return;
@@ -253,16 +251,12 @@ function fns( model ) {
   }
 
   function checkSourceRef( art, path ) { // for FROM
-    if (art.kind === 'entity' )
-      return false;
-    if (art.kind !== 'element')
-      return true;
+    if (!art._main)
+      return (art.kind !== 'entity');
     const elem = path.find( item => item._artifact._main )._artifact;
-    // TODO: better error location if error for main
-    if (elem._main.kind !== 'entity' )
-      return true;              // elem not starting at entity
-    VolatileFns.environment( art );         // sets _effectiveType on art
-    return !(art._effectiveType || art).target;
+    // at least the last main definition should be an entity
+    // an additional check for target would need effectiveType()
+    return (elem && elem._main.kind !== 'entity');
   }
 
   // Return absolute name for unchecked path `ref`.  We first try searching for
@@ -313,7 +307,6 @@ function fns( model ) {
       // incomplete type AST or empty env (already reported)
       return setArtifactLink( ref, undefined );
     }
-    setArtifactLink( ref, 0 );   // avoid cycles for  type T: association to T.m;
 
     let spec = specExpected[expected];
     const { path } = ref;
@@ -324,10 +317,12 @@ function fns( model ) {
 
     if (ref.scope === 'param') {
       if (!spec.escape) {
-        error( 'ref-unexpected-scope', [ ref.location, user ], {},
-               'Unexpected parameter reference' );
+        error( 'ref-unexpected-scope', [ ref.location, user ], { '#': 'std' } );
         return setArtifactLink( ref, null );
       }
+      if (user.$syntax === 'calc')
+        error('ref-unexpected-scope', [ ref.location, user ], { '#': 'calc' } );
+
       spec = specExpected[spec.escape];
       // In queries and query entities, the first lexical search environment
       // are the parameters, otherwise the block.  It is currently ensured that
@@ -363,8 +358,12 @@ function fns( model ) {
       return setArtifactLink( ref, art );
     }
     else if (!spec.envFn && user._pathHead) {
-      if (art.kind === '$self')
-        rejectBareSelf( spec, path, user, extDict );
+      if (art.kind === '$self') {
+        const headEnv = VolatileFns.environment( user._pathHead ) &&
+              user._pathHead._origin &&
+              VolatileFns.environment( user._pathHead._origin );
+        rejectBareSelf( spec, path, user, headEnv );
+      }
     }
     else if (art.kind === 'using') {
       const def = model.definitions[art.name.absolute];
@@ -464,13 +463,13 @@ function fns( model ) {
                  spec.noDep === 'only-entity' && art.kind !== 'entity')) {
       const { location } = ref; // || combinedLocation( head, path[tail.length] );
       // TODO: location of last path item if not main artifact
-      if (!art._main || spec.assoc !== 'from') {
-        dependsOn( user, art, location );
-      }
-      else {
+      if (spec.assoc === 'from' && art._main) {
         dependsOn( user, art._main, location );
         VolatileFns.environment( art, location, user );
-      // Without on-demand resolve, we can simply signal 'undefined "x"'
+      }
+      else if (art.kind !== 'select') { // no real dependency to bare $self
+        dependsOn( user, art, location );
+        // Without on-demand resolve, we can simply signal 'undefined "x"'
       // instead of 'illegal cycle' in the following case:
       //    element elem: type of elem.x;
       }
@@ -772,12 +771,13 @@ function fns( model ) {
 
       const fn = (spec.envFn && artItemsCount >= 0) ? spec.envFn : VolatileFns.environment;
       const env = fn( art, item.location, user, spec.assoc );
-      const sub = setArtifactLink( item, env && env[item.id] );
+      const sub = setArtifactLink( item, env?.[item.id] );
 
       if (!sub) {
         // element was not found in environment
-        if (sub === 0)
-          return 0;
+
+        // TODO (done?): if `env` was 0, we might set a dependency to induce an
+        // illegal-cycle error instead of reporting via `errorNotFound`.
         if (art.$uncheckedElements) { // magic variable / replacement variable
           signalNotFound( 'ref-unknown-var', [ item.location, user ], [ env ],
                           { id: pathName( path ) } );
@@ -971,26 +971,24 @@ function fns( model ) {
       info( 'anno-builtin', [ construct.name.location, construct ], {},
             'Builtin types should not be annotated. Use custom type instead' );
     }
-    else if (construct.$syntax === 'returns' && art._block && art.kind !== 'action' &&
-             art.kind !== 'function' ) {
-      // `annotate ABC with returns {}` is handled just like `elements`. Warn if it is used
-      // for non-actions.  We can't only check for !art.returns, because `action A();` is valid.
-      // `art._block` ensures that `art` is a defined def.
-      warning('anno-unexpected-returns', [ construct.name.location, construct ],
-              { keyword: 'returns', meta: art.kind }, 'Unexpected $(KEYWORD) for $(META)');
-    }
-  }
-
-  // Copy annotations from `ext` to `art`, overwriting inferred ones.
-  // TODO: move to extend.js if not used anymore in define.js
-  function copyAnnotationsForExtensions( ext, art ) {
-    for (const annoProp in ext) {
-      if (annoProp.charAt(0) === '@' || annoProp === 'doc') {
-        const extAnno = ext[annoProp];
-        if (art[annoProp]?.$inferred)
-          art[annoProp] = extAnno; // overwrite $inferred annos
-        else
-          dictAddArray( art, annoProp, extAnno );
+    // --> without art._block, art not found
+    else if (construct.kind === 'annotate' && art._block?.$frontend === 'cdl') {
+      if (construct.$syntax === 'returns' && art.kind !== 'action' && art.kind !== 'function' ) {
+        // `annotate ABC with returns {}` is handled just like `elements`. Warn if it is used
+        // for non-actions.  We can't only check for !art.returns, because `action A();` is valid.
+        // `art._block` ensures that `art` is a defined def.
+        warning('ext-unexpected-returns', [ construct.name.location, construct ],
+                { keyword: 'returns', meta: art.kind }, 'Unexpected $(KEYWORD) for $(META)');
+      }
+      else if (construct.$syntax !== 'returns' &&
+          (art.kind === 'action' || art.kind === 'function') && construct.elements) {
+        warning('ext-expected-returns', [ construct.name.location, construct ], {
+          '#': art.kind, keyword: 'returns', code: 'annotate ‹name› with returns { … }',
+        }, {
+          std: 'Expected $(CODE)', // unused variant
+          action: 'Expected $(KEYWORD) when annotating action return structure, i.e. $(CODE)',
+          function: 'Expected $(KEYWORD) when annotating function return structure, i.e. $(CODE)',
+        });
       }
     }
   }

package/lib/compiler/tweak-assocs.js

@@ -3,7 +3,6 @@
 'use strict';
 
 const {
-  forEachDefinition,
   forEachGeneric,
   forEachInOrder,
 } = require('../base/model');
@@ -31,19 +30,13 @@ function tweakAssocs( model ) {
   } = model.$messageFunctions;
   const {
     effectiveType,
-    directType,
+    getOrigin,
     resolveExpr,
   } = model.$functions;
   const { environment } = model.$volatileFunctions;
 
   // Phase 5: rewrite associations
-  forEachDefinition( model, rewriteSimple );
-  // TODO: sequence not good enough with derived type of structure with
-  // includes: first "direct" structures, then _entities, then the rest.
-  // v2: We might run a silent cycle detection earlier, then we could use the
-  // SCC number (_scc.lowlink) to sort.
-  model._entities.forEach( rewriteView );
-  model._entities.forEach( rewriteViewCheck );
+  model._entities.forEach( rewriteArtifact );
   // Think hard whether an on condition rewrite can lead to a new cylcic
   // dependency.  If so, we need other messages anyway.  TODO: probably do
   // another cyclic check with testMode.js
@@ -55,33 +48,41 @@ function tweakAssocs( model ) {
   //--------------------------------------------------------------------------
   // Only top-level queries and sub queries in FROM
 
-  function rewriteSimple( art ) {
+  function rewriteArtifact( art ) {
     // return;
-    if (!art.includes && !art.query) {
+    if (!art.query) {
       // console.log(message( null, art.location, art, {target:art._target},
       //   'Info','RAS').toString())
       rewriteAssociation( art );
       forEachGeneric( art, 'elements', rewriteAssociation );
     }
+    else {
+      traverseQueryExtra( art, ( query ) => {
+        forEachGeneric( query, 'elements', rewriteAssociation );
+      } );
+    }
     if (art._service)
       forEachGeneric( art, 'elements', excludeAssociation );
-  }
 
-  function rewriteView( view ) {
-    traverseQueryExtra( view, ( query ) => {
-      forEachGeneric( query, 'elements', rewriteAssociation );
+    traverseQueryPost( art.query, false, ( query ) => {
+      forEachGeneric( query, 'elements', rewriteAssociationCheck );
     } );
-    if (view.includes)          // entities with structure includes:
-      forEachGeneric( view, 'elements', rewriteAssociation );
   }
 
+  // function rewriteView( view ) {
+  //   // TODO: we could sort according to the $effectiveSeqNo instead
+  //   // (and then remove traverseQueryExtra)
+  //   if (view.includes)          // entities with structure includes:
+  //     forEachGeneric( view, 'elements', rewriteAssociation );
+  // }
+
   // Check explicit ON / keys with REDIRECTED TO
   // TODO: run on all queries, but this is potentially incompatible
-  function rewriteViewCheck( view ) {
-    traverseQueryPost( view.query, false, ( query ) => {
-      forEachGeneric( query, 'elements', rewriteAssociationCheck );
-    } );
-  }
+  // function rewriteViewCheck( view ) {
+  //   traverseQueryPost( view.query, false, ( query ) => {
+  //     forEachGeneric( query, 'elements', rewriteAssociationCheck );
+  //   } );
+  // }
 
   function excludeAssociation( elem ) {
     const target = elem.target && elem.target._artifact;
@@ -112,7 +113,7 @@ function tweakAssocs( model ) {
     if (!elem.target)
       return;
     if (elem.on && !elem.on.$inferred) {
-      const assoc = directType( elem );
+      const assoc = getOrigin( elem );
       if (assoc && assoc.foreignKeys) {
         error( 'rewrite-key-for-unmanaged', [ elem.on.location, elem ],
                { keyword: 'on', art: assocWithExplicitSpec( assoc ) },
@@ -121,7 +122,7 @@ function tweakAssocs( model ) {
       }
     }
     else if (elem.foreignKeys && !inferredForeignKeys( elem.foreignKeys )) {
-      const assoc = directType( elem );
+      const assoc = getOrigin( elem );
       if (assoc && assoc.on) {
         error( 'rewrite-on-for-managed',
                [ elem.foreignKeys[$location] || dictLocation( elem.foreignKeys ), elem ],
@@ -195,7 +196,7 @@ function tweakAssocs( model ) {
   function assocWithExplicitSpec( assoc ) {
     while (assoc.foreignKeys && inferredForeignKeys( assoc.foreignKeys, 'keys') ||
            assoc.on && assoc.on.$inferred)
-      assoc = directType( assoc );
+      assoc = getOrigin( assoc );
     return assoc;
   }
 
@@ -211,6 +212,7 @@ function tweakAssocs( model ) {
     // With cyclic dependencies on select items, testing for the _effectiveType to
     // be 0 (test above) is not enough if we we have an explicit redirection
     // target -> avoid infloop ourselves with _status.
+    // TODO: this should be good now
     const chain = [];
     while (!elem.on && !elem.foreignKeys) {
       chain.push( elem );
@@ -220,7 +222,7 @@ function tweakAssocs( model ) {
         return;
       }
       setLink( elem, '_status', 'rewrite' );
-      elem = directType( elem );
+      elem = getOrigin( elem );
       if (!elem || elem.builtin) // safety
         return;
     }
@@ -236,7 +238,7 @@ function tweakAssocs( model ) {
   }
 
   function originTarget( elem ) {
-    const assoc = !elem.expand && directType( elem );
+    const assoc = !elem.expand && getOrigin( elem );
     const ftype = assoc && effectiveType( assoc );
     return ftype && ftype.target && ftype.target._artifact;
   }

package/lib/compiler/utils.js

@@ -10,7 +10,7 @@
 
 'use strict';
 
-const { dictAdd, pushToDict } = require('../base/dictionaries');
+const { dictAdd, pushToDict, dictFirst } = require('../base/dictionaries');
 const { kindProperties } = require('./base');
 
 // for links, i.e., properties starting with an underscore '_':
@@ -71,10 +71,11 @@ function annotateWith( art, anno, location = art.location, val = true, literal =
 
 // The link (_artifact,_effectiveType,...) usually has the artifact as value.
 // Falsy values are:
-// - undefined: not computed yet, parse error, no ref
-// - null: no valid reference, param:true if that is not allowed
+// - undefined: not computed yet, parse error (TODO: null), no ref
+// - null: ref to unknown, param:true if that is not allowed (TODO: false)
 // - false (only complete ref): multiple definitions, rejected
 // - 0 (for _effectiveType only): circular reference
+// - '' (for _origin only): no origin provided
 function setLink( obj, prop, value ) {
   Object.defineProperty( obj, prop, { value, configurable: true, writable: true } );
   return value;
@@ -105,6 +106,20 @@ function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
   return elem;
 }
 
+function proxyCopyMembers( art, dictProp, originDict, location, kind ) {
+  art[dictProp] = Object.create( null );
+  for (const name in originDict) {
+    const origin = originDict[name];
+    const member = linkToOrigin( origin, name, art, dictProp,
+                                 location || origin.location, true );
+    member.$inferred = 'expanded';
+    if (kind)
+      member.kind = kind;
+    if (kind && origin.masked)  // TODO: remove!
+      member.masked = Object.assign( { $inferred: 'nav' }, origin.masked );
+  }
+}
+
 /**
  * Set the member `elem` to have a _parent link to `parent` and a corresponding
  * _main link.  Also set the member's name accordingly, where argument `name`
@@ -370,6 +385,15 @@ function traverseQueryExtra( main, callback ) {
   }
 }
 
+// Returns what was available at view._from[0] before:
+// (think first whether to really use this function)
+function viewFromPrimary( view ) {
+  let query = view.$queries?.[0];
+  while (query?._origin?.kind === 'select') // sub query in from
+    query = query._origin;
+  return dictFirst( query?.$tableAliases );
+}
+
 // About Helper property $expand for faster the XSN-to-CSN transformation
 // - null/undefined: artifact, member, items does not contain expanded members
 // - 'origin': all expanded (sub) elements have no new target/on and no new annotations
@@ -428,6 +452,7 @@ module.exports = {
   setLink,
   setArtifactLink,
   linkToOrigin,
+  proxyCopyMembers,
   dependsOn,
   dependsOnSilent,
   setMemberParent,
@@ -441,6 +466,7 @@ module.exports = {
   targetMaxNotOne,
   traverseQueryPost,
   traverseQueryExtra,
+  viewFromPrimary,
   setExpandStatus,
   setExpandStatusAnnotate,
   isDirectComposition,

package/lib/edm/annotations/genericTranslation.js

@@ -1179,21 +1179,15 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
       }
     }
     else if (typeof value === 'number') {
-      if (isComplexType(resolvedType)) {
+      if (isComplexType(resolvedType) ||
+          resolvedType === 'Edm.PropertyPath' ||
+          resolvedType === 'Edm.Boolean') {
         message('odata-anno-value', msg.location,
-        { anno: msg.anno(), value, type: resolvedType });
+          { anno: msg.anno(), value, type: resolvedType });
       }
       else if (resolvedType === 'Edm.String') {
         typeName = 'String';
       }
-      else if (resolvedType === 'Edm.PropertyPath') {
-        message('odata-anno-value', msg.location,
-        { anno: msg.anno(), value, type: resolvedType });
-      }
-      else if (resolvedType === 'Edm.Boolean') {
-        message('odata-anno-value', msg.location,
-        { anno: msg.anno(), value, type: resolvedType });
-      }
       else if (resolvedType === 'Edm.Decimal') {
         typeName = 'Decimal';
       }
@@ -1204,18 +1198,18 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefine
         //typeName = Number.isInteger(val) ? 'Int' : 'Float';
         if(Number.isInteger(value)) {
           typeName = 'Int';
-          if(resolvedType == undefined || resolvedType === 'Edm.PrimitiveType' || !resolvedType.startsWith('Edm.'))
+          if(resolvedType == null || resolvedType === 'Edm.PrimitiveType' || !resolvedType.startsWith('Edm.'))
             resolvedType = 'Edm.Int64';
         }
         else {
           typeName = 'Float';
-          if(resolvedType == undefined || resolvedType === 'Edm.PrimitiveType'|| !resolvedType.startsWith('Edm.'))
+          if(resolvedType == null || resolvedType === 'Edm.PrimitiveType'|| !resolvedType.startsWith('Edm.'))
             resolvedType = 'Edm.Double';
         }
       }
     }
     else if (value === null)
-      if((resolvedType == null || resolvedType == 'Edm.PrimitiveType') && typeName === 'String') {
+      if((resolvedType == null || resolvedType === 'Edm.PrimitiveType') && typeName === 'String') {
         resolvedType = 'Edm.String';
       }
       else {

package/lib/edm/annotations/preprocessAnnotations.js

@@ -63,6 +63,9 @@ function preprocessAnnotations(csn, serviceName, options) {
         artifact.elements && Object.entries(artifact.elements).forEach(([elementName, element]) => {
           handleAnnotations(artifactName, elementName, element, [ ...location, 'elements', elementName ]);
         });
+        artifact.params && Object.entries(artifact.params).forEach(([paramName, param]) => {
+          handleAnnotations(artifactName, paramName, param, [ ...location, 'actions', artifactName, 'params', paramName ]);
+        });
         forEachGeneric(artifact, 'actions', (action, actionName) => {
           action.params && Object.entries(action.params).forEach(([paramName, param]) => {
             handleAnnotations(actionName, paramName, param, [ ...location, 'actions', actionName, 'params', paramName ]);

package/lib/edm/csn2edm.js

@@ -518,10 +518,6 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         const properties = createProperties(elementsCsn, structuredTypeCsn)[0];
         const loc = ['definitions', structuredTypeCsn.name];
 
-        if(properties.length === 0) {
-          warning(null, loc, { name: structuredTypeCsn.name },
-          'EDM ComplexType $(NAME) has no properties');
-        }
         if(!edmUtils.isODataSimpleIdentifier(attributes.Name))
           message('odata-spec-violation-id', loc, { id: attributes.Name });
 

package/lib/edm/edm.js

@@ -749,7 +749,7 @@ function getEdm(options, messageFunctions) {
       this._edmAttributes && Object.entries(this._edmAttributes).forEach(([p, v]) => {
         if (p !== 'Name' && p !== this._typeName
           // remove this line if Nullable=true becomes default
-          && !(p === 'Nullable' && v == false))
+          && !(p === 'Nullable' && !v))
         {
           json[p[0] === '@' ? p : '$' + p] = v;
         }
@@ -763,7 +763,7 @@ function getEdm(options, messageFunctions) {
     }
   }
 
-  class ComplexType extends TypeBase { 
+  class ComplexType extends TypeBase {
     constructor(v, details, csn) {
       super(v, details, csn);
       if(this.v4 && !!csn['@open'] && isBetaEnabled(options, 'odataOpenType')) {
@@ -979,6 +979,7 @@ function getEdm(options, messageFunctions) {
       // TIPHANACDS-4180
       if(this.v2)
       {
+        // eslint-disable-next-line sonarjs/no-redundant-boolean
         if(csn['@odata.etag'] == true || csn['@cds.etag'] == true)
           this._edmAttributes.ConcurrencyMode='Fixed'
 
@@ -1101,8 +1102,8 @@ function getEdm(options, messageFunctions) {
           delete this._edmAttributes.Nullable;
         }
         // we have exactly one selfReference or the default partner
-        let partner = 
-          !csn.$noPartner ? 
+        let partner =
+          !csn.$noPartner ?
             csn._selfReferences.length === 1
               ? csn._selfReferences[0]
               : csn._constraints._partnerCsn
@@ -1121,6 +1122,7 @@ function getEdm(options, messageFunctions) {
           See csn2edm.createParmeterizedEntityTypeAndSet() for details
           2) ContainsTarget stems from the @odata.contained annotation
         */
+        // eslint-disable-next-line sonarjs/no-redundant-boolean
         if(csn['@odata.contained'] == true || csn.containsTarget) {
           this._edmAttributes.ContainsTarget = true;
         }

package/lib/edm/edmAnnoPreprocessor.js

@@ -70,6 +70,7 @@ function applyAppSpecificLateCsnTransformationOnElement(options, element, struct
   // for @[odata|cds].etag annotations...
   if(options.isV4())
   {
+    // eslint-disable-next-line sonarjs/no-redundant-boolean
     if(element['@odata.etag'] == true || element['@cds.etag'] == true) {
       // don't put element name into collection as per advice from Ralf Handl, as
       // no runtime is interested in the property itself, it is sufficient to mark

package/lib/edm/edmPreprocessor.js

@@ -100,10 +100,6 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
 
   /*
     Enrich the CSN by de-anonymizing and exposing types that are required to make the service self contained.
-    Type exposure will add additional schema contexts and group the exposed types in these contexts.
-    Contexts either represent another service (if the type to be exposed resides in that
-    service), the namespace (including (sub-)contexts) or as last resort (if the type name
-     has no prefix path) a 'root' namespace.
   */
   const schemas = typesExposure(csn, whatsMyServiceRootName, requestedServiceNames,
     fallBackSchemaName, options, csnUtils, { error });
@@ -1933,7 +1929,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         const localRestrictions = container[NavResAnno] ?
           cloneAnnotationValue(container[NavResAnno]) : []
 
-        // prefix the existing navigation property restritictions on the container
+        // prefix the existing navigation property restrictions on the container
         if(prefix.length) {
           localRestrictions.forEach(npe => {
             if(npe.NavigationProperty &&

package/lib/gen/Dictionary.json

@@ -512,6 +512,14 @@
       ],
       "$experimental": true
     },
+    "Common.IsTimezone": {
+      "Type": "Core.Tag",
+      "AppliesTo": [
+        "Property",
+        "Parameter"
+      ],
+      "$experimental": true
+    },
     "Common.IsDigitSequence": {
       "Type": "Core.Tag",
       "AppliesTo": [
@@ -1376,6 +1384,16 @@
         "Function"
       ]
     },
+    "Core.RequiresExplicitBinding": {
+      "Type": "Core.Tag",
+      "AppliesTo": [
+        "Action",
+        "Function"
+      ]
+    },
+    "Core.ExplicitOperationBindings": {
+      "Type": "Collection(Core.QualifiedBoundOperationName)"
+    },
     "Core.SymbolicName": {
       "Type": "Core.SimpleIdentifier"
     },
@@ -1457,30 +1475,35 @@
     "Measures.ISOCurrency": {
       "Type": "Edm.String",
       "AppliesTo": [
+        "Parameter",
         "Property"
       ]
     },
     "Measures.Scale": {
       "Type": "Edm.Byte",
       "AppliesTo": [
+        "Parameter",
         "Property"
       ]
     },
     "Measures.Unit": {
       "Type": "Edm.String",
       "AppliesTo": [
+        "Parameter",
         "Property"
       ]
     },
     "Measures.UNECEUnit": {
       "Type": "Edm.String",
       "AppliesTo": [
+        "Parameter",
         "Property"
       ]
     },
     "Measures.DurationGranularity": {
       "Type": "Measures.DurationGranularityType",
       "AppliesTo": [
+        "Parameter",
         "Property"
       ]
     },
@@ -3360,6 +3383,10 @@
       "$kind": "TypeDefinition",
       "UnderlyingType": "Edm.String"
     },
+    "Core.QualifiedBoundOperationName": {
+      "$kind": "TypeDefinition",
+      "UnderlyingType": "Edm.String"
+    },
     "Core.LocalDateTime": {
       "$kind": "TypeDefinition",
       "UnderlyingType": "Edm.String"
@@ -3455,6 +3482,7 @@
         "Border": "Edm.Boolean",
         "FitToPage": "Edm.Boolean",
         "Padding": "Edm.Boolean",
+        "HeaderFooter": "Edm.Boolean",
         "ResultSizeDefault": "Edm.Int32",
         "ResultSizeMaximum": "Edm.Int32"
       }
@@ -3939,7 +3967,7 @@
       "$kind": "ComplexType",
       "BaseType": "UI.DataFieldForActionAbstract",
       "Properties": {
-        "Action": "Common.ActionOverload",
+        "Action": "UI.ActionName",
         "InvocationGrouping": "UI.OperationGroupingType",
         "Inline": "Edm.Boolean",
         "Determining": "Edm.Boolean",
@@ -3994,7 +4022,7 @@
       "BaseType": "UI.DataField",
       "Properties": {
         "Value": "Edm.PrimitiveType",
-        "Action": "Common.QualifiedName",
+        "Action": "UI.ActionName",
         "Label": "Edm.String",
         "Criticality": "UI.CriticalityType",
         "CriticalityRepresentation": "UI.CriticalityRepresentationType",
@@ -4258,6 +4286,10 @@
         "Symbols": {}
       }
     },
+    "UI.ActionName": {
+      "$kind": "TypeDefinition",
+      "UnderlyingType": "Edm.String"
+    },
     "Validation.AllowedValue": {
       "$kind": "ComplexType",
       "Properties": {

package/lib/gen/language.checksum

@@ -1 +1 @@
-7c3a66be27eceea68bf48c9f4eba8164
+6c1cc14fd8155dcb48908afb59568b42