@typemf/generator 0.5.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typemf/generator",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -30,9 +30,9 @@
     "provenance": true
   },
   "dependencies": {
-    "@typemf/core": "0.5.0",
-    "@typemf/node": "0.5.0",
-    "@typemf/xmi": "0.5.0",
+    "@typemf/core": "0.5.1",
+    "@typemf/node": "0.5.1",
+    "@typemf/xmi": "0.5.1",
     "nunjucks": "^3.2.4",
     "prettier": "^3.9.8"
   },

package/templates/typescript/eclass.njk

@@ -74,9 +74,7 @@ export class {{ eClass.getName() }}Impl extends {{ (superClass.getName() + "Impl
   private _{{ feature.getName() }}Cache: BasicEList<{{ tsScalarType(feature) }}> | undefined;
 
   private get _{{ feature.getName() }}(): BasicEList<{{ tsScalarType(feature) }}> {
-    if (!this._{{ feature.getName() }}Cache) {
-      this._{{ feature.getName() }}Cache = new BasicEList<{{ tsScalarType(feature) }}>(this, get{{ packageClassName(package) }}Ref().get{{ eClass.getName() }}_{{ ucfirst(feature.getName()) }}());
-    }
+    this._{{ feature.getName() }}Cache ??= new BasicEList<{{ tsScalarType(feature) }}>(this, get{{ packageClassName(package) }}Ref().get{{ eClass.getName() }}_{{ ucfirst(feature.getName()) }}());
     return this._{{ feature.getName() }}Cache;
   }
 {% else %}
@@ -359,7 +357,7 @@ export class {{ eClass.getName() }}Impl extends {{ (superClass.getName() + "Impl
 {% if superClass %}
         return super.eGet(feature);
 {% else %}
-        throw new Error(`{{ eClass.getName() }} has no feature with id ${feature.getFeatureID()}`);
+        throw new Error(`{{ eClass.getName() }} has no feature with id ${String(feature.getFeatureID())}`);
 {% endif %}
     }
   }
@@ -404,7 +402,7 @@ export class {{ eClass.getName() }}Impl extends {{ (superClass.getName() + "Impl
         super.eSet(feature, value);
         return;
 {% else %}
-        throw new Error(`{{ eClass.getName() }} has no feature with id ${feature.getFeatureID()}`);
+        throw new Error(`{{ eClass.getName() }} has no feature with id ${String(feature.getFeatureID())}`);
 {% endif %}
     }
   }
@@ -420,21 +418,29 @@ export class {{ eClass.getName() }}Impl extends {{ (superClass.getName() + "Impl
       the first place - only its ID. Ordinary callers (eSet, generated
       bean setters) are unaffected; they still pass a real feature and
       get identical behavior. #}
-  eBasicSetValue(feature: EStructuralFeature | number, value: unknown): void {
+{#- The `value` parameter is only genuinely used when some case below assigns it, or when
+    delegating to a superclass - for a class with no single-valued, non-computed features of
+    its own AND no supertype (e.g. a classifier with only many-valued features, or none at
+    all), the switch body below is just "default: throw", and `value` would otherwise be an
+    unused parameter. Naming it `_value` in exactly that case (tsc's noUnusedParameters, like
+    the conventional ESLint argsIgnorePattern, ignores a leading underscore) avoids that
+    without a `void value;` marker statement, which `no-meaningless-void-operator`-style lint
+    rules flag as pointless. #}
+{% set valueParam = "value" if (singleValuedFeatures(ownFeatures).length > 0 or superClass) else "_value" %}
+  eBasicSetValue(feature: EStructuralFeature | number, {{ valueParam }}: unknown): void {
     const featureId = typeof feature === 'number' ? feature : feature.getFeatureID();
     switch (featureId) {
 {% for feature in singleValuedFeatures(ownFeatures) %}
 {% if not featureGetter(feature) %}
-      case {{ feature.getFeatureID() }}: this._{{ feature.getName() }} = value as {{ tsOptionalScalarType(feature) }}; return;
+      case {{ feature.getFeatureID() }}: this._{{ feature.getName() }} = {{ valueParam }} as {{ tsOptionalScalarType(feature) }}; return;
 {% endif %}
 {% endfor %}
       default:
 {% if superClass %}
-        super.eBasicSetValue(feature, value);
+        super.eBasicSetValue(feature, {{ valueParam }});
         return;
 {% else %}
-        void value;
-        throw new Error(`Feature ${featureId} on {{ eClass.getName() }} is many-valued or unknown.`);
+        throw new Error(`Feature ${String(featureId)} on {{ eClass.getName() }} is many-valued or unknown.`);
 {% endif %}
     }
   }
@@ -456,7 +462,7 @@ export class {{ eClass.getName() }}Impl extends {{ (superClass.getName() + "Impl
 {% for feature in ownFeatures %}
 {% if feature.isMany() and not featureGetter(feature) %}
       case {{ feature.getFeatureID() }}:
-        if (!this._{{ feature.getName() }}Cache) this._{{ feature.getName() }}Cache = new BasicEList<{{ tsScalarType(feature) }}>(this);
+        this._{{ feature.getName() }}Cache ??= new BasicEList<{{ tsScalarType(feature) }}>(this);
         return this._{{ feature.getName() }}Cache;
 {% endif %}
 {% endfor %}
@@ -464,7 +470,7 @@ export class {{ eClass.getName() }}Impl extends {{ (superClass.getName() + "Impl
 {% if superClass %}
         return super.eBootstrapList(featureId);
 {% else %}
-        throw new Error(`Feature ${featureId} on {{ eClass.getName() }} is single-valued or unknown.`);
+        throw new Error(`Feature ${String(featureId)} on {{ eClass.getName() }} is single-valued or unknown.`);
 {% endif %}
     }
   }
@@ -514,7 +520,7 @@ export class {{ eClass.getName() }}Impl extends {{ (superClass.getName() + "Impl
 {% if superClass %}
         return super.eIsSet(feature);
 {% else %}
-        throw new Error(`{{ eClass.getName() }} has no feature with id ${feature.getFeatureID()}`);
+        throw new Error(`{{ eClass.getName() }} has no feature with id ${String(feature.getFeatureID())}`);
 {% endif %}
     }
   }
@@ -551,7 +557,7 @@ export class {{ eClass.getName() }}Impl extends {{ (superClass.getName() + "Impl
         super.eUnset(feature);
         return;
 {% else %}
-        throw new Error(`{{ eClass.getName() }} has no feature with id ${feature.getFeatureID()}`);
+        throw new Error(`{{ eClass.getName() }} has no feature with id ${String(feature.getFeatureID())}`);
 {% endif %}
     }
   }

package/templates/typescript/efactory.njk

@@ -31,7 +31,7 @@ export class {{ factoryClassName(package) }}Impl extends {{ useImport("EFactoryI
   }
 {% endfor %}
 
-  create(eClass: {{ useImport("EClass", "types", {foundational: true}) }}): {{ useImport("EObject", "types", {foundational: true}) }} {
+  override create(eClass: {{ useImport("EClass", "types", {foundational: true}) }}): {{ useImport("EObject", "types", {foundational: true}) }} {
     switch (eClass.getClassifierID()) {
 {% for classifier in concreteEClassesOf(package) %}
       case {{ useImport("Ids", "root", {file: packageClassName(package), foundational: false}) }}.{{ classifier.getName() }}.self:

package/templates/typescript/epackage.njk

@@ -44,20 +44,61 @@ export interface {{ pkgClass }} extends {{ useImport("EPackage", "types", {found
 }
 {% endfile %}
 {% file "impl/" + pkgClass + "Impl.ts" %}
+{#- Every foundational Impl class below is only actually referenced in the body further down
+    when the package genuinely contains the classifier/feature/annotation kind it backs (e.g.
+    EEnumImpl is only `new`'d if some classifier here is an EEnum) - importing it unconditionally
+    produced an unused import, and therefore a lint error, for every package missing that kind
+    (e.g. a package with no EOperations never uses EOperationImpl/EParameterImpl at all). These
+    flags mirror that same condition once, up front, so each import below is requested only when
+    the body will actually use it. EFactoryImpl is never referenced in this file's body at all
+    (only efactory.njk's own generated file extends it) and so is not imported here regardless. #}
+{% set needsAttribute = false %}
+{% set needsReference = false %}
+{% set needsOperation = false %}
+{% set needsParameter = false %}
+{% set needsDataType = false %}
+{% set needsEnum = false %}
+{% set needsEnumLiteral = false %}
+{% set needsAnnotation = false %}
+{% if package.getEAnnotations().size() > 0 %}{% set needsAnnotation = true %}{% endif %}
+{% for classifier in package.getEClassifiers() %}
+{% if classifier.getEAnnotations().size() > 0 %}{% set needsAnnotation = true %}{% endif %}
+{% if isEClass(classifier) %}
+{% for feature in classifier.getEStructuralFeatures() %}
+{% if isEReference(feature) %}{% set needsReference = true %}{% else %}{% set needsAttribute = true %}{% endif %}
+{% if feature.getEAnnotations().size() > 0 %}{% set needsAnnotation = true %}{% endif %}
+{% endfor %}
+{% for op in classifier.getEOperations() %}
+{% set needsOperation = true %}
+{% if op.getEAnnotations().size() > 0 %}{% set needsAnnotation = true %}{% endif %}
+{% if op.getEParameters().size() > 0 %}{% set needsParameter = true %}{% endif %}
+{% for param in op.getEParameters() %}
+{% if param.getEAnnotations().size() > 0 %}{% set needsAnnotation = true %}{% endif %}
+{% endfor %}
+{% endfor %}
+{% elif isEEnum(classifier) %}
+{% set needsEnum = true %}
+{% for literal in classifier.getELiterals() %}
+{% set needsEnumLiteral = true %}
+{% if literal.getEAnnotations().size() > 0 %}{% set needsAnnotation = true %}{% endif %}
+{% endfor %}
+{% else %}
+{% set needsDataType = true %}
+{% endif %}
+{% endfor %}
 {% for name in metaclassAccessorCollisionTypeNames(package) %}
 {% set _ = useImport(name, "types", {foundational: true}) %}
 {% endfor %}
 {% set _ = useImport("EPackageImpl", "impl", {foundational: true}) %}
 {% set _ = useImport("EClassImpl", "impl", {foundational: true}) %}
-{% set _ = useImport("EAttributeImpl", "impl", {foundational: true}) %}
-{% set _ = useImport("EReferenceImpl", "impl", {foundational: true}) %}
-{% set _ = useImport("EOperationImpl", "impl", {foundational: true}) %}
-{% set _ = useImport("EParameterImpl", "impl", {foundational: true}) %}
-{% set _ = useImport("EDataTypeImpl", "impl", {foundational: true}) %}
-{% set _ = useImport("EEnumImpl", "impl", {foundational: true}) %}
-{% set _ = useImport("EEnumLiteralImpl", "impl", {foundational: true}) %}
-{% set _ = useImport("EAnnotationImpl", "impl", {foundational: true}) %}
-{% set _ = useImport("EFactoryImpl", "impl", {foundational: true}) %}
+{% if needsAttribute %}{% set _ = useImport("EAttributeImpl", "impl", {foundational: true}) %}{% endif %}
+{% if needsReference %}{% set _ = useImport("EReferenceImpl", "impl", {foundational: true}) %}{% endif %}
+{% if needsOperation %}{% set _ = useImport("EOperationImpl", "impl", {foundational: true}) %}{% endif %}
+{% if needsParameter %}{% set _ = useImport("EParameterImpl", "impl", {foundational: true}) %}{% endif %}
+{% if needsDataType %}{% set _ = useImport("EDataTypeImpl", "impl", {foundational: true}) %}{% endif %}
+{% if needsEnum %}{% set _ = useImport("EEnumImpl", "impl", {foundational: true}) %}{% endif %}
+{% if needsEnumLiteral %}{% set _ = useImport("EEnumLiteralImpl", "impl", {foundational: true}) %}{% endif %}
+{% if needsAnnotation %}{% set _ = useImport("EAnnotationImpl", "impl", {foundational: true}) %}{% endif %}
 {% set _ = useImport(pkgClass, "root", {foundational: false}) %}
 {% set _ = useImport("Ids", "root", {file: pkgClass, foundational: false}) %}
 {% set _ = useImport(factoryClassName(package), "root", {foundational: false}) %}

package/templates/typescript/eswitch.njk

@@ -17,15 +17,18 @@ export abstract class {{ switchClassName(package) }}<T> {
     }
   }
 
+{#- `_object` (not `object`): every stub below always returns `undefined` without looking at
+    its argument - it exists purely as an override point for subclasses, which are free to
+    name their own parameter however they like (TypeScript overriding is structural, not
+    name-based). A leading underscore says so directly and avoids the `void object;` marker
+    statement a merely-unused `object` parameter would otherwise need. #}
 {% for classifier in eClassesOf(package) %}
-  case{{ classifier.getName() }}(object: {{ useImport(classifier.getName(), "types", {foundational: false}) }}): T | undefined {
-    void object;
+  case{{ classifier.getName() }}(_object: {{ useImport(classifier.getName(), "types", {foundational: false}) }}): T | undefined {
     return undefined;
   }
 {% endfor %}
 
-  defaultCase(object: {{ useImport("EObject", "types", {foundational: true}) }}): T | undefined {
-    void object;
+  defaultCase(_object: {{ useImport("EObject", "types", {foundational: true}) }}): T | undefined {
     return undefined;
   }
 }