fix(core): The migration to the inject function handle overridden services correctly.

Fix angular#62232

Author: aparzi

packages/core/schematics/ng-generate/inject-migration/migration.ts

@@ -427,6 +427,8 @@ function createInjectReplacementCall(
     }
   }
 
+  const originalParameterType = type ? type.getText() : '';
+
   for (const decorator of decorators) {
     if (decorator.moduleName !== moduleName) {
       continue;
@@ -514,7 +516,33 @@ function createInjectReplacementCall(
     );
   }
 
-  return replaceNodePlaceholder(param.getSourceFile(), expression, injectedType, printer);
+  let result = replaceNodePlaceholder(sourceFile, expression, injectedType, printer);
+
+  if (originalParameterType && injectedType && needsExplicitCast(originalParameterType, injectedType, param, localTypeChecker)) {
+    let expressionWithoutTypes: ts.CallExpression | ts.NonNullExpression | ts.BinaryExpression = ts.factory.createCallExpression(injectRef, undefined, args);
+
+    if (hasOptionalDecorator && options.nonNullableOptional) {
+      const hasNullableType = param.questionToken != null || (param.type != null && isNullableType(param.type));
+
+      if (!hasNullableType) {
+        expressionWithoutTypes = ts.factory.createNonNullExpression(expressionWithoutTypes);
+      }
+    }
+
+    if (param.initializer) {
+      expressionWithoutTypes = ts.factory.createBinaryExpression(
+        expressionWithoutTypes,
+        ts.SyntaxKind.QuestionQuestionToken,
+        param.initializer,
+      );
+    }
+
+    result = replaceNodePlaceholder(sourceFile, expressionWithoutTypes, injectedType, printer);
+    return `${result} as ${originalParameterType}`;
+
+  } else {
+    return result;
+  }
 }
 
 /**
@@ -864,13 +892,14 @@ function replaceParameterReferencesInInitializer(
       localTypeChecker
         .getSymbolAtLocation(node)
         ?.declarations?.some((decl) =>
-          constructor.parameters.includes(decl as ts.ParameterDeclaration),
-        )
+        constructor.parameters.includes(decl as ts.ParameterDeclaration),
+      )
     ) {
       insertLocations.push(node.getStart() - initializer.getStart());
     }
     ts.forEachChild(node, walk);
   }
+
   walk(initializer);
 
   const initializerText = initializer.getText();
@@ -892,3 +921,80 @@ function isStringType(node: ts.Expression, checker: ts.TypeChecker): boolean {
   // stringLiteral here is to cover const strings inferred as literal type.
   return !!(type.flags & ts.TypeFlags.String || type.flags & ts.TypeFlags.StringLiteral);
 }
+
+/**
+ * Check if necessary an explicit cast for parameter
+ * @param originalType Parameter original type
+ * @param injectedType Service type to inject
+ * @param param The parameter to analyze
+ * @param localTypeChecker Type checker for types analysis
+ */
+function needsExplicitCast(
+  originalType: string,
+  injectedType: string,
+  param: ts.ParameterDeclaration,
+  localTypeChecker: ts.TypeChecker,
+): boolean {
+
+  if (originalType === injectedType) {
+    return false;
+  }
+
+  if (!param.type) {
+    return false;
+  }
+
+  try {
+    const parameterType = localTypeChecker.getTypeFromTypeNode(param.type);
+    const parameterSymbol = parameterType.getSymbol();
+
+    if (!parameterSymbol) {
+      return false;
+    }
+
+    const parameterDeclaration = parameterSymbol.valueDeclaration;
+    if (!parameterDeclaration || !ts.isClassDeclaration(parameterDeclaration)) {
+      return false;
+    }
+
+    const hasInheritance = parameterDeclaration.heritageClauses?.some(clause =>
+      clause.token === ts.SyntaxKind.ExtendsKeyword,
+    );
+
+    if (hasInheritance) {
+      return true;
+    }
+
+    return checkInheritanceRelationship(originalType, injectedType);
+
+  } catch (error) {
+    return false;
+  }
+}
+
+function checkInheritanceRelationship(
+  derivedTypeName: string,
+  baseTypeName: string,
+): boolean {
+
+  if (derivedTypeName.includes(baseTypeName)) {
+    return true;
+  }
+
+  const commonPatterns = [
+    /Extended(.+)/,
+    /Custom(.+)/,
+    /Enhanced(.+)/,
+    /(.+)Impl/,
+    /(.+)Extended/,
+  ];
+
+  for (const pattern of commonPatterns) {
+    const derivedMatch = derivedTypeName.match(pattern);
+    if (derivedMatch && baseTypeName.includes(derivedMatch[1])) {
+      return true;
+    }
+  }
+
+  return false;
+}

packages/core/schematics/test/inject_migration_spec.ts

@@ -2933,5 +2933,47 @@ describe('inject migration', () => {
         `}`,
       ]);
     });
+
+    it('should migrate and handle overridden services correctly.', async () => {
+      writeFile(
+        '/dir.ts',
+        [
+          `import { Component, Inject, Injectable } from '@angular/core';`,
+
+          `@Injectable()`,
+          `export class FileService {`,
+          `  getUrl() {`,
+          `    return 'file';`,
+          `  }`,
+          `}`,
+
+          `@Injectable()`,
+          `export class ExtendedFileService extends FileService {`,
+          `prefix: string = '';`,
+
+          `  override getUrl() {`,
+          `    return this.prefix + '/file';`,
+          `  }`,
+          `}`,
+
+          `@Component({`,
+          `  selector: 'app-root',`,
+          `  providers: [{ provide: FileService, useClass: ExtendedFileService }],`,
+          `  template: Hello world! {{fs.getUrl()}}`,
+          `})`,
+          `export class Playground {`,
+          `  constructor(@Inject(FileService) protected fs: ExtendedFileService) {`,
+          `    this.fs.prefix = 'a';`,
+          `  }`,
+          `}`,
+        ].join('\n'),
+      );
+
+      await runMigration();
+
+      expect(tree.readContent('/dir.ts')).toContain(
+        'protected fs = inject(FileService) as ExtendedFileService;'
+      );
+    });
   });
 });