Merge pull request #1234 from Quramy/resolve_reference_to_call_expression

feat: Resolve interpolation referring call expression

Author: Quramy

src/ts-ast-util/__snapshots__/template-expression-resolver.test.ts.snap

@@ -68,3 +68,20 @@ exports[`resolve string combinination pattern should return combined string with
                   ...Foo
                 }"
 `;
+
+exports[`resolve string combinination pattern should return combined string with template in call expression 1`] = `
+"
+                
+                
+                fragment Foo on Hoge {
+                  name
+                }
+              
+                fragment Piyo on Hoge {
+                  ...Foo
+                }
+              
+                query {
+                  ...Piyo
+                }"
+`;

src/ts-ast-util/template-expression-resolver.test.ts

@@ -505,6 +505,44 @@ describe(TemplateExpressionResolver.prototype.resolve, () => {
       expect(actual?.combinedText).toMatchSnapshot();
     });
 
+    it('should return combined string with template in call expression', () => {
+      const langService = createTestingLanguageService({
+        files: [
+          {
+            fileName: 'main.ts',
+            content: `
+              const fragment1 = gql(\`
+                fragment Foo on Hoge {
+                  name
+                }
+              \`);
+              const fragment2 = gql(\`
+                \${fragment1}
+                fragment Piyo on Hoge {
+                  ...Foo
+                }
+              \`);
+              const query = \`
+                \${fragment2}
+                query {
+                  ...Piyo
+                }\`;
+            `,
+          },
+        ],
+      });
+      const source = langService.getProgram()!.getSourceFile('main.ts');
+      if (!source) return fail();
+      const [, node] = findAllNodes(source, node => ts.isTemplateExpression(node));
+      const resolver = new TemplateExpressionResolver(
+        langService,
+        () => '',
+        () => false,
+      );
+      const actual = resolver.resolve('main.ts', node as ts.TemplateExpression).resolvedInfo;
+      expect(actual?.combinedText).toMatchSnapshot();
+    });
+
     it('should return combined string with hopping reference', () => {
       const langService = createTestingLanguageService({
         files: [

src/ts-ast-util/template-expression-resolver.ts

@@ -371,6 +371,13 @@ export class TemplateExpressionResolver {
       } else {
         return setValueToCache(getValueForTemplateExpression(node.template, dependencies));
       }
+    } else if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.arguments.length > 0) {
+      const firstArgNode = node.arguments[0];
+      if (ts.isNoSubstitutionTemplateLiteral(firstArgNode)) {
+        return setValueToCache({ text: firstArgNode.text, dependencies });
+      } else if (ts.isTemplateExpression(firstArgNode)) {
+        return setValueToCache(getValueForTemplateExpression(firstArgNode, dependencies));
+      }
     } else if (ts.isTemplateExpression(node)) {
       return setValueToCache(getValueForTemplateExpression(node, dependencies));
     }