@tslite/services 0.0.0-stage → 1.12.0

package/dist/goToDefinition.js

@@ -0,0 +1,246 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/goToDefinition.ts: o namespace virou módulo ES, com os imports explícitos.
+import { FindAllReferences, IndexKind, SymbolDisplay, SymbolFlags, SyntaxKind, createTextSpan, createTextSpanFromNode, emptyArray, filter, first, flatMap, getContainingObjectLiteralElement, getInvokedExpression, getNameFromPropertyName, getNameOfDeclaration, getPropertySymbolsFromContextualType, getTouchingPropertyName, isAssignmentDeclaration, isBindingElement, isCallExpressionTarget, isCallLikeExpression, isFunctionLike, isFunctionTypeNode, isObjectBindingPattern, isPropertyAccessExpression, isPropertyName, isRightSideOfPropertyAccess, isVariableDeclaration, last, map, mapDefined, tryCast, } from "./_namespaces/ts.js";
+/**
+ * Na tag, também a referência `/// <reference path>`, `<reference types>` e `<reference lib>` na posição, que dava o
+ * arquivo referido (CK-03, CK-46, CK-39), e o label de um `break` ou `continue` (CK-02).
+ */
+export function getDefinitionAtPosition(program, sourceFile, position) {
+    const node = getTouchingPropertyName(sourceFile, position);
+    if (node === sourceFile) {
+        return undefined;
+    }
+    const { parent } = node;
+    const typeChecker = program.getTypeChecker();
+    const symbol = getSymbol(node, typeChecker);
+    // Could not find a symbol e.g. node is string or number keyword,
+    // or the symbol was an internal symbol and does not have a declaration e.g. undefined symbol
+    if (!symbol) {
+        return getDefinitionInfoForIndexSignatures(node, typeChecker);
+    }
+    const calledDeclaration = tryGetSignatureDeclaration(typeChecker, node);
+    // Na tag, a chamada de um elemento JSX não ia ao construtor do componente (CK-02).
+    if (calledDeclaration) {
+        const sigInfo = createDefinitionFromSignatureDeclaration(typeChecker, calledDeclaration);
+        // For a function, if this is the original function definition, return just sigInfo.
+        // Na tag, também a variável inicializada por um `require()` (CK-03).
+        if (typeChecker.getRootSymbols(symbol).some(s => symbolMatchesSignature(s, calledDeclaration))) {
+            return [sigInfo];
+        }
+        else {
+            const defs = getDefinitionFromSymbol(typeChecker, symbol, node, calledDeclaration) || emptyArray;
+            // A variável primeiro. Na tag, a assinatura vinha primeiro na chamada do `super()` (CK-02).
+            return [...defs, sigInfo];
+        }
+    }
+    // Because name in short-hand property assignment has two different meanings: property name and property value,
+    // using go-to-definition at such position should go to the variable declaration of the property value rather than
+    // go to the declaration of the property name (in this case stay at the same position). However, if go-to-definition
+    // is performed at the location of property access, we would like to go to definition of the property in the short-hand
+    // assignment. This case and others are handled by the following code.
+    if (node.parent.kind === SyntaxKind.ShorthandPropertyAssignment) {
+        const shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration);
+        return shorthandSymbol ? shorthandSymbol.declarations.map(decl => createDefinitionInfo(decl, typeChecker, shorthandSymbol, node)) : [];
+    }
+    // If the node is the name of a BindingElement within an ObjectBindingPattern instead of just returning the
+    // declaration the symbol (which is itself), we should try to get to the original type of the ObjectBindingPattern
+    // and return the property declaration for the referenced property.
+    // For example:
+    //      import('./foo').then(({ b/*goto*/ar }) => undefined); => should get use to the declaration in file "./foo"
+    //
+    //      function bar<T>(onfulfilled: (value: T) => void) { //....}
+    //      interface Test {
+    //          pr/*destination*/op1: number
+    //      }
+    //      bar<Test>(({pr/*goto*/op1})=>{});
+    if (isPropertyName(node) && isBindingElement(parent) && isObjectBindingPattern(parent.parent) &&
+        (node === (parent.propertyName || parent.name))) {
+        const name = getNameFromPropertyName(node);
+        const type = typeChecker.getTypeAtLocation(parent.parent);
+        return name === undefined ? emptyArray : flatMap(type.isUnion() ? type.types : [type], t => {
+            const prop = t.getProperty(name);
+            return prop && getDefinitionFromSymbol(typeChecker, prop, node);
+        });
+    }
+    // If the current location we want to find its definition is in an object literal, try to get the contextual type for the
+    // object literal, lookup the property symbol in the contextual type, and use this for goto-definition.
+    // For example
+    //      interface Props{
+    //          /*first*/prop1: number
+    //          prop2: boolean
+    //      }
+    //      function Foo(arg: Props) {}
+    //      Foo( { pr/*1*/op1: 10, prop2: true })
+    const element = getContainingObjectLiteralElement(node);
+    if (element) {
+        const contextualType = element && typeChecker.getContextualType(element.parent);
+        if (contextualType) {
+            return flatMap(getPropertySymbolsFromContextualType(element, typeChecker, contextualType, /*unionSymbolOk*/ false), propertySymbol => getDefinitionFromSymbol(typeChecker, propertySymbol, node));
+        }
+    }
+    return getDefinitionFromSymbol(typeChecker, symbol, node);
+}
+/**
+ * True if we should not add definitions for both the signature symbol and the definition symbol.
+ * True for `const |f = |() => 0`, false for `function |f() {} const |g = f;`.
+ */
+function symbolMatchesSignature(s, calledDeclaration) {
+    return s === calledDeclaration.symbol || s === calledDeclaration.symbol.parent ||
+        !isCallLikeExpression(calledDeclaration.parent) && s === calledDeclaration.parent.symbol;
+}
+/// Goto type
+export function getTypeDefinitionAtPosition(typeChecker, sourceFile, position) {
+    const node = getTouchingPropertyName(sourceFile, position);
+    if (node === sourceFile) {
+        return undefined;
+    }
+    const symbol = typeChecker.getSymbolAtLocation(node);
+    if (!symbol)
+        return undefined;
+    const typeAtLocation = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
+    const returnType = tryGetReturnTypeOfFunction(symbol, typeAtLocation, typeChecker);
+    const fromReturnType = returnType && definitionFromType(returnType, typeChecker, node);
+    // If a function returns 'void' or some other type with no definition, just return the function definition.
+    return fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node);
+}
+/** Na tag, a união de um enum ficava inteira, e não membro a membro (CK-02). */
+function definitionFromType(type, checker, node) {
+    return flatMap(type.isUnion() ? type.types : [type], t => t.symbol && getDefinitionFromSymbol(checker, t.symbol, node));
+}
+function tryGetReturnTypeOfFunction(symbol, type, checker) {
+    // If the type is just a function's inferred type,
+    // go-to-type should go to the return type instead, since go-to-definition takes you to the function anyway.
+    if (type.symbol === symbol ||
+        // At `const f = () => {}`, the symbol is `f` and the type symbol is at `() => {}`
+        symbol.valueDeclaration && type.symbol && isVariableDeclaration(symbol.valueDeclaration) && symbol.valueDeclaration.initializer === type.symbol.valueDeclaration) {
+        const sigs = type.getCallSignatures();
+        if (sigs.length === 1)
+            return checker.getReturnTypeOfSignature(first(sigs));
+    }
+    return undefined;
+}
+export function getDefinitionAndBoundSpan(program, sourceFile, position) {
+    const definitions = getDefinitionAtPosition(program, sourceFile, position);
+    if (!definitions || definitions.length === 0) {
+        return undefined;
+    }
+    // Na tag, a posição numa referência `/// <reference …>` dava o trecho dela (CK-03, CK-46, CK-39).
+    const node = getTouchingPropertyName(sourceFile, position);
+    const textSpan = createTextSpan(node.getStart(), node.getWidth());
+    return { definitions, textSpan };
+}
+// At 'x.foo', see if the type of 'x' has an index signature, and if so find its declarations.
+function getDefinitionInfoForIndexSignatures(node, checker) {
+    if (!isPropertyAccessExpression(node.parent) || node.parent.name !== node)
+        return;
+    const type = checker.getTypeAtLocation(node.parent.expression);
+    return mapDefined(type.isUnionOrIntersection() ? type.types : [type], nonUnionType => {
+        const info = checker.getIndexInfoOfType(nonUnionType, IndexKind.String);
+        return info && info.declaration && createDefinitionFromSignatureDeclaration(checker, info.declaration);
+    });
+}
+function getSymbol(node, checker) {
+    const symbol = checker.getSymbolAtLocation(node);
+    // If this is an alias, and the request came at the declaration location
+    // get the aliased symbol instead. This allows for goto def on an import e.g.
+    //   import {A, B} from "mod";
+    // to jump to the implementation directly.
+    if (symbol && symbol.flags & SymbolFlags.Alias && shouldSkipAlias(node, symbol.declarations[0])) {
+        const aliased = checker.getAliasedSymbol(symbol);
+        if (aliased.declarations) {
+            return aliased;
+        }
+    }
+    // Na tag, a variável de um arquivo JavaScript inicializada por um `require()` dava o módulo (CK-03).
+    return symbol;
+}
+// Go to the original declaration for cases:
+//
+//   (1) when the aliased symbol was declared in the location(parent).
+//   (2) when the aliased symbol is originating from an import.
+//
+function shouldSkipAlias(node, declaration) {
+    if (node.kind !== SyntaxKind.Identifier) {
+        return false;
+    }
+    if (node.parent === declaration) {
+        return true;
+    }
+    // Na tag, também o `import =` (CK-03).
+    switch (declaration.kind) {
+        case SyntaxKind.ImportClause:
+            return true;
+        case SyntaxKind.ImportSpecifier:
+            return declaration.parent.kind === SyntaxKind.NamedImports;
+        default:
+            return false;
+    }
+}
+function getDefinitionFromSymbol(typeChecker, symbol, node, declarationNode) {
+    // There are cases when you extend a function by adding properties to it afterwards,
+    // we want to strip those extra properties.
+    // For deduping purposes, we also want to exclude any declarationNodes if provided.
+    const filteredDeclarations = filter(symbol.declarations, d => d !== declarationNode && (!isAssignmentDeclaration(d) || d === symbol.valueDeclaration)) || undefined;
+    // Na tag, primeiro a construct signature da classe, no alvo de um `new` ou no `constructor` (CK-02).
+    return getCallSignatureDefinition() || map(filteredDeclarations, declaration => createDefinitionInfo(declaration, typeChecker, symbol, node));
+    /** Na tag, também no alvo de um `new` e no nome de uma `function` declarada (CK-02). */
+    function getCallSignatureDefinition() {
+        return isCallExpressionTarget(node)
+            ? getSignatureDefinition(filteredDeclarations)
+            : undefined;
+    }
+    /** Na tag, também os construtores de uma classe (o `selectConstructors`, CK-02). */
+    function getSignatureDefinition(signatureDeclarations) {
+        if (!signatureDeclarations) {
+            return undefined;
+        }
+        const declarations = signatureDeclarations.filter(isFunctionLike);
+        const declarationsWithBody = declarations.filter(d => !!d.body);
+        // declarations defined on the global scope can be defined on multiple files. Get all of them.
+        return declarations.length
+            ? declarationsWithBody.length !== 0
+                ? declarationsWithBody.map(x => createDefinitionInfo(x, typeChecker, symbol, node))
+                : [createDefinitionInfo(last(declarations), typeChecker, symbol, node)]
+            : undefined;
+    }
+}
+/** Creates a DefinitionInfo from a Declaration, using the declaration's name if possible. */
+function createDefinitionInfo(declaration, checker, symbol, node) {
+    const symbolName = checker.symbolToString(symbol); // Do not get scoped name, just the name of the symbol
+    const symbolKind = SymbolDisplay.getSymbolKind(checker, symbol, node);
+    const containerName = symbol.parent ? checker.symbolToString(symbol.parent, node) : "";
+    return createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName);
+}
+/** Creates a DefinitionInfo directly from the name of a declaration. */
+function createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName) {
+    const name = getNameOfDeclaration(declaration) || declaration;
+    const sourceFile = name.getSourceFile();
+    const textSpan = createTextSpanFromNode(name, sourceFile);
+    return {
+        fileName: sourceFile.fileName,
+        textSpan,
+        kind: symbolKind,
+        name: symbolName,
+        containerKind: undefined,
+        containerName,
+        ...FindAllReferences.toContextSpan(textSpan, sourceFile, FindAllReferences.getContextNode(declaration)),
+        isLocal: !checker.isDeclarationVisible(declaration)
+    };
+}
+function createDefinitionFromSignatureDeclaration(typeChecker, decl) {
+    return createDefinitionInfo(decl, typeChecker, decl.symbol, decl);
+}
+/** Returns a CallLikeExpression where `node` is the target being invoked. */
+function getAncestorCallLikeExpression(node) {
+    const target = climbPastManyPropertyAccesses(node);
+    const callLike = target.parent;
+    return callLike && isCallLikeExpression(callLike) && getInvokedExpression(callLike) === target ? callLike : undefined;
+}
+function climbPastManyPropertyAccesses(node) {
+    return isRightSideOfPropertyAccess(node) ? climbPastManyPropertyAccesses(node.parent) : node;
+}
+function tryGetSignatureDeclaration(typeChecker, node) {
+    const callLike = getAncestorCallLikeExpression(node);
+    const signature = callLike && typeChecker.getResolvedSignature(callLike);
+    // Don't go to a function type, go to the value having that type.
+    return tryCast(signature && signature.declaration, (d) => isFunctionLike(d) && !isFunctionTypeNode(d));
+}

package/dist/importTracker.d.ts

@@ -0,0 +1,50 @@
+import type { CancellationToken, CheckResult, Identifier, Node, ReadonlyMap, SourceFile, StringLiteral, StringLiteralLike, Symbol, TypeChecker } from "./_namespaces/ts.js";
+export interface ImportsResult {
+    /** For every import of the symbol, the location and local symbol for the import. */
+    importSearches: readonly [Identifier, Symbol][];
+    /** For rename imports/exports `{ foo as bar }`, `foo` is not a local, so it may be added as a reference immediately without further searching. */
+    singleReferences: readonly (Identifier | StringLiteral)[];
+    /** Os arquivos que podem usar o símbolo por um namespace. Na tag, todo arquivo quando o módulo era UMD (CK-03). */
+    indirectUsers: readonly SourceFile[];
+}
+export type ImportTracker = (exportSymbol: Symbol, exportInfo: ExportInfo, isForRename: boolean) => ImportsResult;
+/** Creates the imports map and returns an ImportTracker that uses it. Call this lazily to avoid calling `getDirectImportsMap` unnecessarily.  */
+export declare function createImportTracker(sourceFiles: readonly SourceFile[], sourceFilesSet: ReadonlyMap<true>, checker: TypeChecker, cancellationToken: CancellationToken | undefined): ImportTracker;
+/** Info about an exported symbol to perform recursive search on. */
+export interface ExportInfo {
+    exportingModuleSymbol: Symbol;
+    exportKind: ExportKind;
+}
+/** Na tag, também o `export =` (CK-03). */
+export declare enum ExportKind {
+    Named = 0,
+    Default = 1
+}
+export declare enum ImportExport {
+    Import = 0,
+    Export = 1
+}
+/** O import de um módulo (também o `require()`). Na tag, também a referência `/// <reference path>` e `<reference types>` (CK-03). */
+export type ModuleReference = {
+    kind: "import";
+    literal: StringLiteralLike;
+};
+export declare function findModuleReferences(program: CheckResult, sourceFiles: readonly SourceFile[], searchModuleSymbol: Symbol): ModuleReference[];
+export interface ImportedSymbol {
+    kind: ImportExport.Import;
+    symbol: Symbol;
+}
+export interface ExportedSymbol {
+    kind: ImportExport.Export;
+    symbol: Symbol;
+    exportInfo: ExportInfo;
+}
+/**
+ * Given a local reference, we might notice that it's an import/export and recursively search for references of that.
+ * If at an import, look locally for the symbol it imports.
+ * If at an export, look for all imports of it.
+ * This doesn't handle export specifiers; that is done in `getReferencesAtExportSpecifier`.
+ * @param comingFromExport If we are doing a search for all exports, don't bother looking backwards for the imported symbol, since that's the reason we're here.
+ */
+export declare function getImportOrExportSymbol(node: Node, symbol: Symbol, checker: TypeChecker, comingFromExport: boolean): ImportedSymbol | ExportedSymbol | undefined;
+export declare function getExportInfo(exportSymbol: Symbol, exportKind: ExportKind, checker: TypeChecker): ExportInfo | undefined;