@finos/legend-graph 5.0.0 → 7.0.0

package/src/models/metamodels/pure/packageableElements/PackageableElement.ts

@@ -17,7 +17,6 @@
 import {
   type Hashable,
   hashArray,
-  hashString,
   IllegalStateError,
   uuid,
 } from '@finos/legend-shared';
@@ -26,7 +25,6 @@ import {
   ELEMENT_PATH_DELIMITER,
 } from '../../../../MetaModelConst';
 import type { Package } from './domain/Package';
-import type { Stubable } from '../../../../helpers/Stubable';
 import type { Profile } from './domain/Profile';
 import type { Enumeration } from './domain/Enumeration';
 import type { Class } from './domain/Class';
@@ -43,6 +41,7 @@ import type { FileGenerationSpecification } from './fileGeneration/FileGeneratio
 import type { GenerationSpecification } from './generationSpecification/GenerationSpecification';
 import type { Measure } from './domain/Measure';
 import type { SectionIndex } from './section/SectionIndex';
+import type { DataElement } from './data/DataElement';
 
 export interface PackageableElementVisitor<T> {
   visit_PackageableElement(element: PackageableElement): T;
@@ -64,13 +63,14 @@ export interface PackageableElementVisitor<T> {
   visit_Service(element: Service): T;
   visit_FileGenerationSpecification(element: FileGenerationSpecification): T;
   visit_GenerationSpecification(element: GenerationSpecification): T;
+  visit_DataElement(element: DataElement): T;
 }
 
-export abstract class PackageableElement implements Hashable, Stubable {
-  readonly uuid = uuid();
-
+export abstract class PackageableElement implements Hashable {
+  readonly _UUID = uuid();
   protected _isDeleted = false;
   protected _isDisposed = false;
+
   name: string;
   package?: Package | undefined;
 
@@ -78,30 +78,53 @@ export abstract class PackageableElement implements Hashable, Stubable {
     this.name = name;
   }
 
+  /**
+   * This logic is specific to the codebase and this is not part of the native metamodel.
+   * If needed, we can probably move this out as an utility or do type declaration merge
+   * and define this externally using `Object.defineProperty`.
+   *
+   * @internal model logic
+   */
   get isDeleted(): boolean {
     return this._isDeleted;
   }
 
+  /**
+   * This logic is specific to the codebase and this is not part of the native metamodel.
+   * If needed, we can probably move this out as an utility or do type declaration merge
+   * and define this externally using `Object.defineProperty`.
+   *
+   * @internal model logic
+   */
   setIsDeleted(value: boolean): void {
     this._isDeleted = value;
   }
 
+  /**
+   * This logic is specific to the codebase and this is not part of the native metamodel.
+   * If needed, we can probably move this out as an utility or do type declaration merge
+   * and define this externally using `Object.defineProperty`.
+   *
+   * @internal model logic
+   */
   get path(): string {
     if (!this.package) {
       return this.name;
     }
-    const parentPackageName = this.package.fullPath;
-    return !parentPackageName
+    const parentPackagePath = this.package.path;
+    return !parentPackagePath
       ? this.name
-      : `${parentPackageName}${ELEMENT_PATH_DELIMITER}${this.name}`;
-  }
-
-  get isStub(): boolean {
-    return !this.name && !this.package;
+      : `${parentPackagePath}${ELEMENT_PATH_DELIMITER}${this.name}`;
   }
 
   /**
-   * Dispose the element and its references to avoid memory leaks
+   * Dispose the element and its references to avoid memory leaks.
+   *
+   * This logic is specific to the codebase and this is not part of the native metamodel.
+   * If needed, we can probably move this out as an utility or do type declaration merge
+   * and define this externally using `Object.defineProperty`.
+   *
+   * @internal model logic
    */
   dispose(): void {
     this._isDisposed = true;
@@ -109,14 +132,12 @@ export abstract class PackageableElement implements Hashable, Stubable {
      * Trigger recomputation on `hashCode` so if the element is observed, hash code computation will now
      * remove itself from all observables it previously observed
      *
-     * NOTE: we used to do this since we decorate `hashCode` with `computed({ keepAlive: true })` which
-     * poses a memory-leak threat
-     *
-     * See https://mobx.js.org/computeds.html#keepalive
-     *
+     * NOTE: for example, we used to do this since we decorate `hashCode` with
+     * `computed({ keepAlive: true })` which poses a memory-leak threat.
      * However, since we're calling `keepAlive` actively now and dispose it right away to return `hashCode` to
      * a normal computed value, we might not need this step anymore. But we're being extremely defensive here
      * to avoid memory leak.
+     * See https://mobx.js.org/computeds.html#keepalive
      */
     try {
       this.hashCode;
@@ -140,42 +161,3 @@ export abstract class PackageableElement implements Hashable, Stubable {
     visitor: PackageableElementVisitor<T>,
   ): T;
 }
-
-// TODO: to be moved out of metamodel
-export enum PACKAGEABLE_ELEMENT_TYPE {
-  PRIMITIVE = 'PRIMITIVE',
-  PACKAGE = 'PACKAGE',
-  PROFILE = 'PROFILE',
-  ENUMERATION = 'ENUMERATION',
-  CLASS = 'CLASS',
-  ASSOCIATION = 'ASSOCIATION',
-  FUNCTION = 'FUNCTION',
-  MEASURE = 'MEASURE',
-  UNIT = 'UNIT',
-  FLAT_DATA_STORE = 'FLAT_DATA_STORE',
-  DATABASE = 'DATABASE',
-  SERVICE_STORE = 'SERVICE_STORE',
-  MAPPING = 'MAPPING',
-  SERVICE = 'SERVICE',
-  CONNECTION = 'CONNECTION',
-  RUNTIME = 'RUNTIME',
-  FILE_GENERATION = 'FILE_GENERATION',
-  GENERATION_SPECIFICATION = 'GENERATION_SPECIFICATION',
-  SECTION_INDEX = 'SECTION_INDEX',
-}
-
-// TODO: to be moved out of metamodel
-export enum PACKAGEABLE_ELEMENT_POINTER_TYPE {
-  STORE = 'STORE',
-  MAPPING = 'MAPPING',
-  FILE_GENERATION = 'FILE_GENERATION',
-  SERVICE = 'SERVICE',
-}
-
-export const getElementPointerHashCode = (
-  pointerType: string,
-  path: string,
-): string =>
-  [CORE_HASH_STRUCTURE.PACKAGEABLE_ELEMENT_POINTER, pointerType, path]
-    .map(hashString)
-    .join(',');

package/src/models/metamodels/pure/packageableElements/PackageableElementReference.ts

@@ -134,7 +134,7 @@ export class PackageableElementImplicitReference<
     // when the parent section does not exist or has been deleted
     if (
       this.parentSection === undefined ||
-      this.parentSection.parent.isDeleted
+      this.parentSection._OWNER.isDeleted
     ) {
       return currentElementPath;
     }
@@ -240,7 +240,7 @@ export class OptionalPackageableElementImplicitReference<
     // when the parent section does not exist or has been deleted
     if (
       this.parentSection === undefined ||
-      this.parentSection.parent.isDeleted
+      this.parentSection._OWNER.isDeleted
     ) {
       return currentElementPath;
     }

package/src/models/metamodels/pure/packageableElements/connection/Connection.ts

@@ -38,9 +38,11 @@ export interface ConnectionVisitor<T> {
 }
 
 export abstract class Connection implements Hashable {
-  readonly uuid = uuid();
+  readonly _UUID = uuid();
 
-  // in Pure right now, this is of type Any[1], but technically it should be a store
+  /**
+   * NOTE: in Pure right now, this is of type Any[1], but technically it should be a store
+   */
   store: PackageableElementReference<Store>;
 
   constructor(store: PackageableElementReference<Store>) {

package/src/models/metamodels/pure/packageableElements/data/DataElement.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { hashArray, type Hashable } from '@finos/legend-shared';
+import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
+import type { EmbeddedData } from '../../data/EmbeddedData';
+import type { StereotypeReference } from '../domain/StereotypeReference';
+import type { TaggedValue } from '../domain/TaggedValue';
+import {
+  PackageableElement,
+  type PackageableElementVisitor,
+} from '../PackageableElement';
+
+export class DataElement extends PackageableElement implements Hashable {
+  stereotypes: StereotypeReference[] = [];
+  taggedValues: TaggedValue[] = [];
+  data!: EmbeddedData;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_ELEMENT,
+      this.path,
+      hashArray(
+        this.stereotypes.map((stereotype) => stereotype.pointerHashCode),
+      ),
+      hashArray(this.taggedValues),
+      this.data,
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_DataElement(this);
+  }
+}

package/src/models/metamodels/pure/packageableElements/domain/AbstractProperty.ts

@@ -17,16 +17,16 @@
 import type { Hashable } from '@finos/legend-shared';
 import type { GenericTypeReference } from './GenericTypeReference';
 import type { Multiplicity } from './Multiplicity';
-import type { Stubable } from '../../../../../helpers/Stubable';
 import type { Class } from './Class';
 import type { Association } from './Association';
 
 // NOTE: In PURE we have `Class` and `Association` extends `PropertyOwner`, which extends `PackageableElement`
 export type PropertyOwner = Class | Association;
 
-export interface AbstractProperty extends Hashable, Stubable {
+export interface AbstractProperty extends Hashable {
+  _OWNER: PropertyOwner;
+
   name: string;
-  owner: PropertyOwner;
   genericType: GenericTypeReference;
   multiplicity: Multiplicity;
 }

package/src/models/metamodels/pure/packageableElements/domain/Association.ts

@@ -14,40 +14,22 @@
  * limitations under the License.
  */
 
-import {
-  type Hashable,
-  guaranteeNonNullable,
-  guaranteeType,
-  assertTrue,
-  UnsupportedOperationError,
-  hashArray,
-} from '@finos/legend-shared';
+import { type Hashable, type Writable, hashArray } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import {
   type PackageableElementVisitor,
   PackageableElement,
 } from '../PackageableElement';
-import { Property } from './Property';
-import { type Stubable, isStubArray } from '../../../../../helpers/Stubable';
-import { Class } from './Class';
+import type { Property } from './Property';
 import type { AnnotatedElement } from './AnnotatedElement';
 import type { TaggedValue } from './TaggedValue';
 import type { StereotypeReference } from './StereotypeReference';
-import { DerivedProperty } from './DerivedProperty';
+import type { DerivedProperty } from './DerivedProperty';
 import type { AbstractProperty } from './AbstractProperty';
-
-// NOTE: we might want to revisit this decision to initialize to association properties to stubs
-const initAssociationProperties = (
-  association: Association,
-): [Property, Property] => {
-  const properties: [Property, Property] = [
-    Property.createStub(Class.createStub(), Class.createStub()),
-    Property.createStub(Class.createStub(), Class.createStub()),
-  ];
-  properties[0].owner = association;
-  properties[1].owner = association;
-  return properties;
-};
+import {
+  stub_Class,
+  stub_Property,
+} from '../../../../../graphManager/action/creation/DomainModelCreatorHelper';
 
 /**
  * Assocation needs exactly 2 properties (for 2 classes, not enumeration, not primitive), e.g.
@@ -62,54 +44,38 @@ const initAssociationProperties = (
  * or project dependencies. As such, in the app, we have to make it very clear that we prohibits this.
  *
  * TODO: We probably should change backend to do compilation check whether association refers
- * to a class from a different project. Here, while building the graph, we can make use of the
+ * to a class from a different projects. Here, while building the graph, we can make use of the
  * root package to verify this in the UI and make this a validation error in a way.
+ * See https://github.com/finos/legend-studio/issues/282
  */
 export class Association
   extends PackageableElement
-  implements AnnotatedElement, Hashable, Stubable
+  implements AnnotatedElement, Hashable
 {
-  properties: [Property, Property] = initAssociationProperties(this);
+  /**
+   * To store the abstract properties generated while processing the milestoning properties. The properties
+   * generated are `allVersions`, `allVersionsInRange` and derived property with date parameter.
+   *
+   * TODO: process new property added while editing the graph
+   */
+  _generatedMilestonedProperties: AbstractProperty[] = [];
+
+  properties!: [Property, Property];
   stereotypes: StereotypeReference[] = [];
   taggedValues: TaggedValue[] = [];
   derivedProperties: DerivedProperty[] = [];
 
-  getFirstProperty = (): Property => guaranteeNonNullable(this.properties[0]);
-  getSecondProperty = (): Property => guaranteeNonNullable(this.properties[1]);
-  getOtherProperty = (property: Property): Property => {
-    const idx = this.properties.findIndex((p) => p === property);
-    assertTrue(
-      idx !== -1,
-      `Can't find property '${property.name}' in association '${this.path}'`,
-    );
-    return guaranteeNonNullable(this.properties[(idx + 1) % 2]);
-  };
-  getPropertyAssociatedClass = (property: AbstractProperty): Class => {
-    if (property instanceof Property) {
-      return guaranteeType(
-        this.getOtherProperty(property).genericType.ownerReference.value,
-        Class,
-        `Association property '${property.name}' must be of type 'class'`,
-      );
-    } else if (property instanceof DerivedProperty) {
-      throw new UnsupportedOperationError(
-        `Derived property is not currently supported in association`,
-      );
-    }
-    throw new UnsupportedOperationError(
-      `Can't get associated class of property`,
-      property,
-    );
-  };
-
-  getProperty = (name: string): Property =>
-    guaranteeNonNullable(
-      this.properties.find((p) => p.name === name),
-      `Can't find property '${name}' in class '${this.path}'`,
-    );
+  constructor(name: string) {
+    super(name);
 
-  override get isStub(): boolean {
-    return super.isStub && isStubArray(this.properties);
+    // NOTE: we might want to revisit this decision to initialize to association properties to stubs
+    const properties: [Property, Property] = [
+      stub_Property(stub_Class(), stub_Class()),
+      stub_Property(stub_Class(), stub_Class()),
+    ];
+    (properties[0] as Writable<Property>)._OWNER = this;
+    (properties[1] as Writable<Property>)._OWNER = this;
+    this.properties = properties;
   }
 
   protected override get _elementHashCode(): string {

package/src/models/metamodels/pure/packageableElements/domain/Class.ts

@@ -14,196 +14,68 @@
  * limitations under the License.
  */
 
-import {
-  type Hashable,
-  hashArray,
-  uniqBy,
-  IllegalStateError,
-  guaranteeNonNullable,
-  UnsupportedOperationError,
-} from '@finos/legend-shared';
-import {
-  CORE_HASH_STRUCTURE,
-  CORE_PURE_PATH,
-} from '../../../../../MetaModelConst';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
 import { Type } from './Type';
 import type { Property } from './Property';
 import type { Constraint } from './Constraint';
 import type { DerivedProperty } from './DerivedProperty';
 import type { AbstractProperty } from './AbstractProperty';
-import { type Stubable, isStubArray } from '../../../../../helpers/Stubable';
 import type { PackageableElementVisitor } from '../PackageableElement';
-import { PrimitiveType } from './PrimitiveType';
-import { Enumeration } from './Enumeration';
-import { Measure, Unit } from './Measure';
 import type { StereotypeReference } from './StereotypeReference';
 import type { TaggedValue } from './TaggedValue';
 import type { GenericTypeReference } from './GenericTypeReference';
 
-export class Class extends Type implements Hashable, Stubable {
-  properties: Property[] = [];
-  // derivedPropertiesFromAssociations: DerivedProperty[] = [];
-  propertiesFromAssociations: Property[] = [];
-  derivedProperties: DerivedProperty[] = [];
-  generalizations: GenericTypeReference[] = [];
+export class Class extends Type implements Hashable {
   /**
    * We can also call this `specifications` (i.e. vs. `generalizations`)
    *
-   * @MARKER MEMORY-SENSITIVE
-   * if this belongs to immutable elements: i.e. in system, project dependency, etc.
+   * If this belongs to immutable elements: i.e. in system, project dependency, etc.
    * we have to make sure to remove of disposed classes from this when we reprocess the graph
+   *
+   * @risk memory-leak
    */
-  subclasses: Class[] = [];
-  constraints: Constraint[] = [];
-  stereotypes: StereotypeReference[] = [];
-  taggedValues: TaggedValue[] = [];
-
-  /**
-   * Get class and its supertypes' properties recursively, duplications and loops are handled (Which should be caught by compiler)
-   */
-  getAllProperties = (): Property[] =>
-    uniqBy(
-      this.allSuperclasses
-        .concat(this)
-        .map((_class) =>
-          _class.propertiesFromAssociations.concat(_class.properties),
-        )
-        .flat(),
-      (p) => p.name,
-    );
-
-  getProperty = (name: string): Property =>
-    guaranteeNonNullable(
-      this.getAllProperties().find((p) => p.name === name),
-      `Can't find property '${name}' in class '${this.path}'`,
-    );
-
-  getAllDerivedProperties = (): DerivedProperty[] =>
-    uniqBy(
-      this.allSuperclasses
-        .concat(this)
-        .map((_class) => _class.derivedProperties)
-        .flat(),
-      (p) => p.name,
-    );
-
-  getAllOwnedProperties = (): AbstractProperty[] =>
-    this.properties
-      .concat(this.propertiesFromAssociations)
-      .concat(this.derivedProperties);
-
-  getOwnedProperty = (name: string): AbstractProperty =>
-    guaranteeNonNullable(
-      this.getAllOwnedProperties().find((p) => p.name === name),
-      `Can't find property '${name}' in class '${this.path}'`,
-    );
-
-  // Perhaps we don't need to care about deduping constraints here like for properties
-  getAllConstraints = (): Constraint[] =>
-    this.allSuperclasses
-      .concat(this)
-      .map((_class) => _class.constraints)
-      .flat();
-
-  isSuperType(type: Type): boolean {
-    return (
-      type.path === CORE_PURE_PATH.ANY ||
-      (type instanceof Class && type.allSuperclasses.includes(this))
-    );
-  }
-
-  isSubType(type: Type): boolean {
-    return (
-      this.path === CORE_PURE_PATH.ANY ||
-      (type instanceof Class && type.allSubclasses.includes(this))
-    );
-  }
-
-  /**
-   * Get all super types of a class, accounted for loop and duplication (which should be caught by compiler)
-   * NOTE: we intentionally leave out `Any`
-   */
-  get allSuperclasses(): Class[] {
-    const visitedClasses = new Set<Class>();
-    visitedClasses.add(this);
-    const resolveSuperTypes = (_class: Class): void => {
-      _class.generalizations.forEach((gen) => {
-        const superType = gen.value.getRawType(Class);
-        if (!visitedClasses.has(superType)) {
-          visitedClasses.add(superType);
-          resolveSuperTypes(superType);
-        }
-      });
-    };
-    resolveSuperTypes(this);
-    visitedClasses.delete(this);
-    return Array.from(visitedClasses);
-  }
-
+  _subclasses: Class[] = [];
   /**
-   * Get all subclasses of a class, accounted for loop and duplication (which should be caught by compiler)
-   * NOTE: we intentionally leave out `Any`
+   * To store the abstract properties generated while processing the milestoning properties. The properties
+   * generated are `allVersions`, `allVersionsInRange` and derived property with date parameter.
    *
-   * @MARKER MEMORY-SENSITIVE
-   * When this is an immutable class such as project dependency or system we need to remember to remove the classes from the sub-types array.
-   * And rerun this computation to avoid potenial memory leak
+   * TODO: process new property added while editing the graph
    */
-  get allSubclasses(): Class[] {
-    if (this._isDisposed) {
-      throw new IllegalStateError(`Element '${this.path}' is already disposed`);
-    }
-    const visitedClasses = new Set<Class>();
-    visitedClasses.add(this);
-    const resolveSubclasses = (_class: Class): void => {
-      if (_class._isDisposed) {
-        return;
-      }
-      _class.subclasses.forEach((subclass) => {
-        if (!visitedClasses.has(subclass)) {
-          visitedClasses.add(subclass);
-          resolveSubclasses(subclass);
-        }
-      });
-    };
-    resolveSubclasses(this);
-    visitedClasses.delete(this);
-    return Array.from(visitedClasses);
-  }
+  _generatedMilestonedProperties: AbstractProperty[] = [];
+
+  properties: Property[] = [];
+  propertiesFromAssociations: Property[] = [];
+  derivedProperties: DerivedProperty[] = [];
+  // derivedPropertiesFromAssociations: DerivedProperty[] = [];
+  generalizations: GenericTypeReference[] = [];
+  constraints: Constraint[] = [];
+  stereotypes: StereotypeReference[] = [];
+  taggedValues: TaggedValue[] = [];
 
   /**
    * Make sure to remove the disposed class from being referenced in other elements
    * e.g. subclass analytics is great, but it causes the class being referred to by classes
    * coming from system or dependencies
+   *
+   * This logic is specific to the codebase and this is not part of the native metamodel.
+   * If needed, we can probably move this out as an utility or do type declaration merge
+   * and define this externally using `Object.defineProperty`.
+   *
+   * @internal model logic
    */
   override dispose(): void {
     super.dispose();
-    this.subclasses = []; // call this before setting `disposed` flag to avoid triggering errors if something is using this during disposal
+    this._subclasses = [];
     // cleanup subclasses analytics on superclasses
-    this.allSuperclasses.forEach((superclass) => {
+    this.generalizations.forEach((genericType) => {
+      const superclass = genericType.value.rawType as Class;
       if (!superclass._isDisposed) {
-        superclass.subclasses = superclass.subclasses.filter(
+        superclass._subclasses = superclass._subclasses.filter(
           (subclass) => !subclass._isDisposed,
         );
       }
     });
-    try {
-      this.allSubclasses;
-    } catch {
-      /* do nothing */
-    } // trigger recomputation on `allSubclasses` so it removes itself from all observables it previously observed
-  }
-
-  static createStub = (): Class => new Class('');
-  override get isStub(): boolean {
-    return (
-      super.isStub &&
-      isStubArray(this.properties) &&
-      isStubArray(this.derivedProperties) &&
-      isStubArray(this.constraints) &&
-      isStubArray(this.generalizations) &&
-      isStubArray(this.stereotypes) &&
-      isStubArray(this.taggedValues)
-    );
   }
 
   protected override get _elementHashCode(): string {
@@ -227,28 +99,3 @@ export class Class extends Type implements Hashable, Stubable {
     return visitor.visit_Class(this);
   }
 }
-
-// TODO: to be moved out of metamodel
-export enum CLASS_PROPERTY_TYPE {
-  CLASS = 'CLASS',
-  ENUMERATION = 'ENUMERATION',
-  MEASURE = 'MEASURE',
-  UNIT = 'UNIT',
-  PRIMITIVE = 'PRIMITIVE',
-}
-
-// TODO: to be moved out of metamodel
-export const getClassPropertyType = (type: Type): CLASS_PROPERTY_TYPE => {
-  if (type instanceof PrimitiveType) {
-    return CLASS_PROPERTY_TYPE.PRIMITIVE;
-  } else if (type instanceof Enumeration) {
-    return CLASS_PROPERTY_TYPE.ENUMERATION;
-  } else if (type instanceof Class) {
-    return CLASS_PROPERTY_TYPE.CLASS;
-  } else if (type instanceof Unit) {
-    return CLASS_PROPERTY_TYPE.UNIT;
-  } else if (type instanceof Measure) {
-    return CLASS_PROPERTY_TYPE.MEASURE;
-  }
-  throw new UnsupportedOperationError(`Can't classify class property`, type);
-};

package/src/models/metamodels/pure/packageableElements/domain/ConcreteFunctionDefinition.ts

@@ -21,7 +21,6 @@ import type { PackageableElementVisitor } from '../PackageableElement';
 import type { RawVariableExpression } from '../../rawValueSpecification/RawVariableExpression';
 import type { Type } from './Type';
 import type { Multiplicity } from './Multiplicity';
-import type { Stubable } from '../../../../../helpers/Stubable';
 import type { StereotypeReference } from './StereotypeReference';
 import type { TaggedValue } from './TaggedValue';
 import type { PackageableElementReference } from '../PackageableElementReference';
@@ -29,12 +28,22 @@ import { FunctionDefinition } from './Function';
 
 export class ConcreteFunctionDefinition
   extends FunctionDefinition
-  implements Hashable, Stubable
+  implements Hashable
 {
   returnType: PackageableElementReference<Type>;
   returnMultiplicity: Multiplicity;
-  parameters: RawVariableExpression[] = []; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
-  body: object[] = []; // @MARKER GENERATED MODEL DISCREPANCY --- Studio does not process lambda
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  parameters: RawVariableExpression[] = [];
+  /**
+   * Studio does not process value specification, they are left in raw JSON form
+   *
+   * @discrepancy model
+   */
+  body: object[] = [];
   stereotypes: StereotypeReference[] = [];
   taggedValues: TaggedValue[] = [];