@cloudcare/hvigor-ohos-plugin 0.1.1 → 0.1.2-alpha.2

package/hvigorCompile/ft-console-log-transform.ts

@@ -7,6 +7,11 @@
  * never changed.
  */
 
+import { hasRuntimeDependency, SourceReader, SourceDiagnosticReporter, parseApplicationSource,
+  reportSourceDiagnostic, reportSourceParseError } from './ft-transform-context';
+import { createLexicalResolver } from './ft-lexical-scope';
+import { allocateName, collectIdentifierNames } from './ft-generated-names';
+
 type TypeScriptApi = any;
 
 interface TransformCandidate {
@@ -17,11 +22,14 @@ interface TransformCandidate {
   level: string;
   source: 'console' | 'hilog';
   callArguments: SourceRange[];
+  needsStatementSeparator: boolean;
+  generatedNames?: string[];
 }
 
 interface SourceRange {
   start: number;
   end: number;
+  spread: boolean;
 }
 
 const HILOG_MODULES: string[] = ['@ohos.hilog', '@kit.PerformanceAnalysisKit'];
@@ -45,74 +53,53 @@ function visit(ts: TypeScriptApi, node: any, visitor: (current: any) => void): v
   ts.forEachChild(node, (child: any) => visit(ts, child, visitor));
 }
 
-function collectIdentifierNames(ts: TypeScriptApi, sourceFile: any): Set<string> {
-  const identifiers = new Set<string>();
-  visit(ts, sourceFile, (node: any) => {
-    if (ts.isIdentifier(node)) {
-      identifiers.add(node.text);
-    }
-  });
-  return identifiers;
-}
-
-function isNameDeclaredOutsideImports(ts: TypeScriptApi, sourceFile: any, name: string): boolean {
-  let declared = false;
-  visit(ts, sourceFile, (node: any) => {
-    if (declared || ts.isImportDeclaration(node)) {
-      return;
-    }
-    if (ts.isVariableDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) ||
-      ts.isParameter(node) || ts.isEnumDeclaration(node) || ts.isInterfaceDeclaration(node) ||
-      ts.isTypeAliasDeclaration(node)) {
-      const declarationName = node.name;
-      if (declarationName && ts.isIdentifier(declarationName) && declarationName.text === name) {
-        declared = true;
-      }
-    }
-  });
-  return declared;
-}
-
-function collectHiLogBindings(ts: TypeScriptApi, sourceFile: any): Set<string> {
-  const bindings = new Set<string>();
+function collectHiLogBindings(ts: TypeScriptApi, sourceFile: any): Map<string, any> {
+  const bindings = new Map<string, any>();
   sourceFile.statements.forEach((statement: any) => {
     if (!ts.isImportDeclaration(statement) || !statement.moduleSpecifier ||
       !ts.isStringLiteral(statement.moduleSpecifier) ||
-      !HILOG_MODULES.includes(statement.moduleSpecifier.text) || !statement.importClause) {
+      !HILOG_MODULES.includes(statement.moduleSpecifier.text) || !statement.importClause || statement.importClause.isTypeOnly) {
       return;
     }
 
     const importClause = statement.importClause;
     if (importClause.name) {
-      bindings.add(importClause.name.text);
+      bindings.set(importClause.name.text, importClause);
     }
     if (!importClause.namedBindings) {
       return;
     }
     if (ts.isNamespaceImport(importClause.namedBindings)) {
-      bindings.add(importClause.namedBindings.name.text);
+      bindings.set(importClause.namedBindings.name.text, importClause.namedBindings);
       return;
     }
     importClause.namedBindings.elements.forEach((element: any) => {
       const importedName = element.propertyName ? element.propertyName.text : element.name.text;
-      if (importedName === 'hilog') {
-        bindings.add(element.name.text);
+      if (importedName === 'hilog' && !element.isTypeOnly) {
+        bindings.set(element.name.text, element);
       }
     });
   });
   return bindings;
 }
 
-function collectCandidates(ts: TypeScriptApi, sourceFile: any, code: string): TransformCandidate[] {
+function needsStatementSeparator(ts: TypeScriptApi, node: any): boolean {
+  const statement = node.parent;
+  if (!ts.isExpressionStatement(statement)) {
+    return false;
+  }
+  const container = statement.parent;
+  // Only statement lists accept a leading empty statement. In an unbraced
+  // if/loop body it would replace the body; inside an expression it is invalid.
+  return ts.isSourceFile(container) || ts.isBlock(container) || ts.isModuleBlock(container) ||
+    ts.isCaseClause(container) || ts.isDefaultClause(container);
+}
+
+function collectCandidates(ts: TypeScriptApi, sourceFile: any, code: string,
+  unsupported: (node: any, message: string) => void): TransformCandidate[] {
   const candidates: TransformCandidate[] = [];
   const hiLogBindings = collectHiLogBindings(ts, sourceFile);
-  const consoleIsShadowed = isNameDeclaredOutsideImports(ts, sourceFile, 'console');
-  const shadowedHiLogBindings = new Set<string>();
-  hiLogBindings.forEach((binding: string) => {
-    if (isNameDeclaredOutsideImports(ts, sourceFile, binding)) {
-      shadowedHiLogBindings.add(binding);
-    }
-  });
+  const resolve = createLexicalResolver(ts, sourceFile);
 
   visit(ts, sourceFile, (node: any) => {
     if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) {
@@ -124,38 +111,47 @@ function collectCandidates(ts: TypeScriptApi, sourceFile: any, code: string): Tr
     }
     const delegateName = delegate.text;
     const level = node.expression.name.text;
+    const isConsole = delegateName === 'console' && !resolve(delegate, delegateName) && CONSOLE_LEVELS.includes(level);
+    const isHiLog = hiLogBindings.has(delegateName) &&
+      resolve(delegate, delegateName) === hiLogBindings.get(delegateName) && HILOG_LEVELS.includes(level);
+    if (!isConsole && !isHiLog) return;
+    // Preserve short-circuit semantics instead of transforming optional calls.
+    if (ts.isOptionalChain && ts.isOptionalChain(node)) {
+      unsupported(node, 'Optional Console/HiLog calls are left unchanged and are not automatically collected.');
+      return;
+    }
     const start = node.getStart(sourceFile);
     const end = node.end;
     const calleeEnd = node.expression.end;
     if (start < 0 || end > code.length || calleeEnd < start || calleeEnd > end) {
+      unsupported(node, 'The compiler returned an invalid source range for this logging call.');
       return;
     }
 
     const callArguments: SourceRange[] = node.arguments.map((argument: any) => ({
       start: argument.getStart(sourceFile),
-      end: argument.end
+      end: argument.end,
+      spread: ts.isSpreadElement(argument)
     }));
-    if (delegateName === 'console' && !consoleIsShadowed && CONSOLE_LEVELS.includes(level)) {
-      candidates.push({ start, end, calleeEnd, delegate: delegateName, level, source: 'console', callArguments });
+    const statementSeparator = needsStatementSeparator(ts, node);
+    if (isConsole) {
+      candidates.push({ start, end, calleeEnd, delegate: delegateName, level, source: 'console', callArguments,
+        needsStatementSeparator: statementSeparator });
       return;
     }
-    if (hiLogBindings.has(delegateName) && !shadowedHiLogBindings.has(delegateName) &&
-      HILOG_LEVELS.includes(level) && callArguments.length >= 3) {
-      candidates.push({ start, end, calleeEnd, delegate: delegateName, level, source: 'hilog', callArguments });
+    if (callArguments.length >= 3 || callArguments.some(argument => argument.spread)) {
+      candidates.push({ start, end, calleeEnd, delegate: delegateName, level, source: 'hilog', callArguments,
+        needsStatementSeparator: statementSeparator });
+    } else {
+      unsupported(node, 'HiLog collection requires domain, tag and format arguments, or a spread argument supplying them.');
     }
   });
   return candidates;
 }
 
-function selectBridgeName(identifiers: Set<string>): string {
-  const baseName = '__ftConsoleLogBridge';
-  let bridgeName = baseName;
-  let suffix = 1;
-  while (identifiers.has(bridgeName)) {
-    bridgeName = `${baseName}${suffix}`;
-    suffix++;
-  }
-  return bridgeName;
+function allocateCandidateNames(candidate: TransformCandidate, identifiers: Set<string>): string[] {
+  const prefix = candidate.source === 'console' ? '__ftConsole' : '__ftHiLog';
+  return ['Call', 'Args', 'Values'].map(suffix => allocateName(identifiers, prefix + suffix));
 }
 
 function isNestedIn(candidate: TransformCandidate, parent: TransformCandidate): boolean {
@@ -187,42 +183,31 @@ function renderCandidate(code: string, candidates: TransformCandidate[], bridgeN
   candidate: TransformCandidate): string {
   const renderedArguments = candidate.callArguments.map((argument: SourceRange) =>
     renderCandidates(code, candidates, bridgeName, argument.start, argument.end));
+  const statementSeparator = candidate.needsStatementSeparator ? ';' : '';
+  const [original, args, values] = candidate.generatedNames!;
+  const valueType = '(Object | null | undefined)';
+  const originalType = candidate.source === 'console' ? `(...${args}: ${valueType}[]) => void` :
+    `(domain: number, tag: string, format: string, ...${values}: ${valueType}[]) => void`;
+  let body: string;
   if (candidate.source === 'console') {
-    const argumentNames = renderedArguments.map((_argument: string, index: number) => `__ftConsoleArg${index}`);
-    const parameterDeclarations = argumentNames.map((name: string) => `${name}: Object`).join(', ');
-    const originalCallArguments = argumentNames.map((name: string) => `${name} as string`);
-    const originalCall = `${candidate.delegate}.${candidate.level}(${originalCallArguments.join(', ')})`;
-    const captureArguments = argumentNames.length > 0 ? `, ${argumentNames.join(', ')}` : '';
-    return `((${parameterDeclarations}): void => ${bridgeName}.console('${candidate.level}', ` +
-      `(): void => ${originalCall}${captureArguments}))(${renderedArguments.join(', ')})`;
+    body = `${bridgeName}.console('${candidate.level}', (): void => ${original}(...${args}), ` +
+      `...(${args} as Object[]))`;
+  } else {
+    const header = `${args}[0] as number, ${args}[1] as string, ${args}[2] as string`;
+    body = `{ const ${values}: ${valueType}[] = ${args}.slice(3); ` +
+      `${bridgeName}.hilog('${candidate.level}', ${header}, (): void => ${original}(${header}, ...${values}), ` +
+      `...(${values} as Object[])); }`;
   }
-
-  const argumentNames = renderedArguments.map((_argument: string, index: number) => {
-    if (index === 0) {
-      return '__ftHiLogDomain';
-    }
-    if (index === 1) {
-      return '__ftHiLogTag';
-    }
-    if (index === 2) {
-      return '__ftHiLogFormat';
-    }
-    return `__ftHiLogArg${index - 3}`;
-  });
-  const parameterDeclarations = argumentNames.map((name: string, index: number) => {
-    if (index === 0) {
-      return `${name}: number`;
-    }
-    if (index === 1 || index === 2) {
-      return `${name}: string`;
-    }
-    return `${name}: Object`;
-  }).join(', ');
-  const originalCall = `${candidate.delegate}.${candidate.level}(${argumentNames.join(', ')})`;
-  const captureArguments = argumentNames.length > 3 ? `, ${argumentNames.slice(3).join(', ')}` : '';
-  return `((${parameterDeclarations}): void => ${bridgeName}.hilog('${candidate.level}', ` +
-    `${argumentNames[0]}, ${argumentNames[1]}, ${argumentNames[2]}, (): void => ${originalCall}` +
-    `${captureArguments}))(${renderedArguments.join(', ')})`;
+  // Resolve and bind the original method before evaluating its arguments.
+  // Casting only the capture array keeps compatibility with older runtime HARs;
+  // null/undefined values themselves are forwarded unchanged.
+  // HiLog is a platform namespace, not an ArkTS object receiver. Its exported
+  // functions are static; console methods retain their receiver through bind.
+  const callee = `${candidate.delegate}.${candidate.level}`;
+  const captured = candidate.source === 'console' ? `${callee}.bind(${candidate.delegate})` : callee;
+  const argumentsText = renderedArguments.length > 0 ? ', ' + renderedArguments.join(', ') : '';
+  return `${statementSeparator}((${original}: ${originalType}, ...${args}: ${valueType}[]): void => ${body})` +
+    `(${captured} as ${originalType}${argumentsText})`;
 }
 
 function findImportInsertionOffset(ts: TypeScriptApi, sourceFile: any): number {
@@ -235,17 +220,26 @@ function findImportInsertionOffset(ts: TypeScriptApi, sourceFile: any): number {
   return offset;
 }
 
-export function transformConsoleLogSource(ts: TypeScriptApi, id: string, code: string): string {
-  if (!isApplicationArkTsSource(id) || code.includes(TRANSFORM_MARKER)) {
+export function transformConsoleLogSource(ts: TypeScriptApi, id: string, code: string, readSource?: SourceReader,
+  reportDiagnostic?: SourceDiagnosticReporter): string {
+  if (!isApplicationArkTsSource(id) || code.includes(TRANSFORM_MARKER) ||
+    !hasRuntimeDependency(ts, id, '@guancecloud/ft_sdk', readSource)) {
     return code;
   }
   const sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-  const candidates = collectCandidates(ts, sourceFile, code);
+  const unsupported: Array<{ node: any; message: string }> = [];
+  const candidates = collectCandidates(ts, sourceFile, code, (node, message) => unsupported.push({ node, message }));
+  if (candidates.length === 0 && unsupported.length === 0) return code;
+  if (reportSourceParseError(ts, parseApplicationSource(ts, id, code), reportDiagnostic)) return code;
+  unsupported.forEach(item => reportSourceDiagnostic(sourceFile, item.node.getStart(sourceFile),
+    'unsupported-log-call', item.message, reportDiagnostic));
   if (candidates.length === 0) {
     return code;
   }
 
-  const bridgeName = selectBridgeName(collectIdentifierNames(ts, sourceFile));
+  const identifiers = collectIdentifierNames(ts, sourceFile);
+  const bridgeName = allocateName(identifiers, '__ftConsoleLogBridge');
+  candidates.forEach(candidate => { candidate.generatedNames = allocateCandidateNames(candidate, identifiers); });
   const transformedCode = renderCandidates(code, candidates, bridgeName, 0, code.length);
   const insertionOffset = findImportInsertionOffset(ts, sourceFile);
   const transformedInsertionOffset = renderCandidates(code, candidates, bridgeName, 0, insertionOffset).length;

package/hvigorCompile/ft-generated-names.ts

@@ -0,0 +1,19 @@
+/** Reserve generated identifiers across all scopes and every nested rewrite. */
+export function allocateName(identifiers: Set<string>, base: string): string {
+  let candidate = base;
+  let suffix = 1;
+  while (identifiers.has(candidate)) candidate = `${base}${suffix++}`;
+  identifiers.add(candidate);
+  return candidate;
+}
+
+export function collectIdentifierNames(ts: any, source: any): Set<string> {
+  const identifiers = new Set<string>();
+  const visit = (node: any): void => {
+    if (ts.isIdentifier(node)) identifiers.add(node.text);
+    if (node.name && ts.isStringLiteral(node.name)) identifiers.add(node.name.text);
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return identifiers;
+}

package/hvigorCompile/ft-lexical-scope.ts

@@ -0,0 +1,65 @@
+/** Value bindings visible at a call site, including declarations later in the same scope. */
+interface Scope {
+  parent?: Scope;
+  functionScope: boolean;
+  bindings: Map<string, any>;
+}
+
+export function createLexicalResolver(ts: any, source: any): (location: any, name: string) => any | undefined {
+  const scopes = new WeakMap<object, Scope>();
+  const root: Scope = { functionScope: true, bindings: new Map() };
+  const bind = (scope: Scope, name: any, declaration: any): void => {
+    if (!name) return;
+    if (ts.isIdentifier(name)) scope.bindings.set(name.text, declaration);
+    else if (name.elements) name.elements.forEach((element: any) => {
+      if (ts.isBindingElement(element)) bind(scope, element.name, declaration);
+    });
+  };
+  const walk = (node: any, outer: Scope): void => {
+    const struct = typeof ts.isStructDeclaration === 'function' && ts.isStructDeclaration(node);
+    const classLike = ts.isClassDeclaration(node) || ts.isClassExpression(node) || struct;
+    if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || struct || ts.isEnumDeclaration(node) ||
+      ts.isModuleDeclaration(node)) && node.name) {
+      bind(outer, node.name, node);
+    }
+    let scope = outer;
+    const functionLike = ts.isFunctionLike(node);
+    if (functionLike || ts.isBlock(node) || ts.isCaseBlock(node) || ts.isCatchClause(node) ||
+      ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node) ||
+      ts.isModuleBlock(node) || classLike) {
+      scope = { parent: outer, functionScope: functionLike || ts.isModuleBlock(node), bindings: new Map() };
+    }
+    scopes.set(node, scope);
+    if (functionLike) {
+      if (ts.isFunctionExpression(node) && node.name) bind(scope, node.name, node);
+      node.parameters.forEach((parameter: any) => bind(scope, parameter.name, parameter));
+    }
+    if (classLike && node.name) bind(scope, node.name, node);
+    if (ts.isVariableDeclaration(node)) {
+      const list = node.parent;
+      let target = scope;
+      if (ts.isVariableDeclarationList(list) && !(list.flags & ts.NodeFlags.BlockScoped)) {
+        while (!target.functionScope && target.parent) target = target.parent;
+      }
+      bind(target, node.name, node);
+    }
+    if (ts.isImportDeclaration(node) && node.importClause && !node.importClause.isTypeOnly) {
+      const clause = node.importClause;
+      if (clause.name) bind(scope, clause.name, clause);
+      const bindings = clause.namedBindings;
+      if (bindings && ts.isNamespaceImport(bindings)) bind(scope, bindings.name, bindings);
+      else if (bindings) bindings.elements.forEach((element: any) => {
+        if (!element.isTypeOnly) bind(scope, element.name, element);
+      });
+    }
+    if (ts.isImportEqualsDeclaration(node) && !node.isTypeOnly) bind(scope, node.name, node);
+    ts.forEachChild(node, (child: any) => walk(child, scope));
+  };
+  walk(source, root);
+  return (location: any, name: string): any | undefined => {
+    for (let scope = scopes.get(location); scope; scope = scope.parent) {
+      if (scope.bindings.has(name)) return scope.bindings.get(name);
+    }
+    return undefined;
+  };
+}