@tslite/services 0.0.0-stage → 1.12.0

package/dist/codefixes/inferFromUsage.js

@@ -0,0 +1,742 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/inferFromUsage.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, Diagnostics, FindAllReferences, ObjectFlags, ScriptTarget, SignatureFlags, SymbolFlags, SyntaxKind, TypeFlags, UnionReduction, cast, createMultiMap, createSymbolTable, createToken, createUnderscoreEscapedMap, escapeLeadingUnderscores, findChildOfKind, first, flatMap, forEach, forEachEntry, getContainingFunction, getNameOfDeclaration, getObjectFlags, getTokenAtPosition, getTypeNodeIfAccessible, isArrowFunction, isAssignmentExpression, isCallExpression, isExpressionNode, isIdentifier, isParameter, isPropertySignature, isRestParameter, isRightSideOfQualifiedNameOrPropertyAccess, isVariableDeclaration, last, mapDefined, mapEntries, nodeSeenTracker, returnTrue, singleOrUndefined, textChanges, tryCast, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, createImportAdder, registerCodeFix, tryGetAutoImportableReferenceFromImportTypeNode, } from "../_namespaces/ts.codefix.js";
+const fixId = "inferFromUsage";
+// Na tag, também o retorno de um getter e o parâmetro de um setter sem anotação, o retorno implícito de uma `function`,
+// de um método ou de um acessor com nome, e o `this` de uma função (CK-02); e a variante de sugestão de cada erro, que só
+// vinha com o `noImplicitAny` desligado (CK-24). A cópia não acusa nenhum deles.
+const errorCodes = [
+    // Variable declarations
+    Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code,
+    // Variable uses
+    Diagnostics.Variable_0_implicitly_has_an_1_type.code,
+    // Parameter declarations
+    Diagnostics.Parameter_0_implicitly_has_an_1_type.code,
+    Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code,
+    // Property declarations
+    Diagnostics.Member_0_implicitly_has_an_1_type.code,
+];
+// O alvo da configuração fixa (CK-24): o do nome que se importa.
+const languageVersion = ScriptTarget.ES2020;
+registerCodeFix({
+    errorCodes,
+    getCodeActions(context) {
+        const { sourceFile, program, span: { start }, errorCode, cancellationToken, host, preferences } = context;
+        const token = getTokenAtPosition(sourceFile, start);
+        let declaration;
+        const changes = textChanges.ChangeTracker.with(context, changes => { declaration = doChange(changes, sourceFile, token, errorCode, program, cancellationToken, /*markSeen*/ returnTrue, host, preferences); });
+        const name = declaration && getNameOfDeclaration(declaration);
+        return !name || changes.length === 0 ? undefined
+            : [createCodeFixAction(fixId, changes, [getDiagnostic(errorCode), name.getText(sourceFile)], fixId, Diagnostics.Infer_all_types_from_usage)];
+    },
+    fixIds: [fixId],
+    getAllCodeActions(context) {
+        const { sourceFile, program, cancellationToken, host, preferences } = context;
+        const markSeen = nodeSeenTracker();
+        return codeFixAll(context, errorCodes, (changes, err) => {
+            doChange(changes, sourceFile, getTokenAtPosition(err.file, err.start), err.code, program, cancellationToken, markSeen, host, preferences);
+        });
+    },
+});
+// Na tag, recebia também o token, e o parâmetro de um setter dava o texto do tipo, e não o dos parâmetros; e o `this`
+// de uma função tinha o texto dele (CK-02).
+function getDiagnostic(errorCode) {
+    switch (errorCode) {
+        case Diagnostics.Parameter_0_implicitly_has_an_1_type.code:
+            return Diagnostics.Infer_parameter_types_from_usage;
+        case Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code:
+            return Diagnostics.Infer_parameter_types_from_usage;
+        default:
+            return Diagnostics.Infer_type_of_0_from_usage;
+    }
+}
+// Na tag, aqui vinha o `mapSuggestionDiagnostic`, que trocava o código de cada sugestão pelo do erro dela: a cópia só dá
+// o erro (CK-24).
+function doChange(changes, sourceFile, token, errorCode, program, cancellationToken, markSeen, host, preferences) {
+    // Na tag, também o modificador de uma parameter property e o `this` (CK-02).
+    if (token.kind !== SyntaxKind.Identifier && token.kind !== SyntaxKind.DotDotDotToken) {
+        return undefined;
+    }
+    const { parent } = token;
+    const importAdder = createImportAdder(sourceFile, program, preferences, host);
+    switch (errorCode) {
+        // Variable and Property declarations
+        case Diagnostics.Member_0_implicitly_has_an_1_type.code:
+        case Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code:
+            // Na tag, também a propriedade de classe (CK-02), e o acesso a uma propriedade num arquivo JavaScript, que
+            // ganhava uma tag `@type` do JSDoc (CK-03).
+            if ((isVariableDeclaration(parent) && markSeen(parent)) || isPropertySignature(parent)) { // handle bad location
+                annotateVariableDeclaration(changes, importAdder, sourceFile, parent, program, host, cancellationToken);
+                importAdder.writeFixes(changes);
+                return parent;
+            }
+            return undefined;
+        case Diagnostics.Variable_0_implicitly_has_an_1_type.code: {
+            const symbol = program.getTypeChecker().getSymbolAtLocation(token);
+            if (symbol && symbol.valueDeclaration && isVariableDeclaration(symbol.valueDeclaration) && markSeen(symbol.valueDeclaration)) {
+                annotateVariableDeclaration(changes, importAdder, sourceFile, symbol.valueDeclaration, program, host, cancellationToken);
+                importAdder.writeFixes(changes);
+                return symbol.valueDeclaration;
+            }
+            return undefined;
+        }
+    }
+    const containingFunction = getContainingFunction(token);
+    if (containingFunction === undefined) {
+        return undefined;
+    }
+    let declaration;
+    switch (errorCode) {
+        // Parameter declarations
+        // Na tag, o parâmetro de um setter anotava o setter (CK-02).
+        case Diagnostics.Parameter_0_implicitly_has_an_1_type.code:
+        case Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code:
+            if (markSeen(containingFunction)) {
+                const param = cast(parent, isParameter);
+                annotateParameters(changes, importAdder, sourceFile, param, containingFunction, program, host, cancellationToken);
+                declaration = param;
+            }
+            break;
+        // Na tag, também o retorno de um getter, o parâmetro de um setter e o `this` de uma função (CK-02).
+        default:
+            return Debug.fail(String(errorCode));
+    }
+    importAdder.writeFixes(changes);
+    return declaration;
+}
+// Na tag, também a propriedade de classe (CK-02).
+function annotateVariableDeclaration(changes, importAdder, sourceFile, declaration, program, host, cancellationToken) {
+    if (isIdentifier(declaration.name)) {
+        annotate(changes, importAdder, sourceFile, declaration, inferTypeForVariableFromUsage(declaration.name, program, cancellationToken), program, host);
+    }
+}
+function annotateParameters(changes, importAdder, sourceFile, parameterDeclaration, containingFunction, program, host, cancellationToken) {
+    if (!isIdentifier(parameterDeclaration.name)) {
+        return;
+    }
+    const parameterInferences = inferTypeForParametersFromUsage(containingFunction, program, cancellationToken);
+    Debug.assert(containingFunction.parameters.length === parameterInferences.length, "Parameter count and inference count should match");
+    // Na tag, num arquivo JavaScript, os tipos iam para tags `@param` do JSDoc (CK-03).
+    const needParens = isArrowFunction(containingFunction) && !findChildOfKind(containingFunction, SyntaxKind.OpenParenToken, sourceFile);
+    if (needParens)
+        changes.insertNodeBefore(sourceFile, first(containingFunction.parameters), createToken(SyntaxKind.OpenParenToken));
+    for (const { declaration, type } of parameterInferences) {
+        if (declaration && !declaration.type && !declaration.initializer) {
+            annotate(changes, importAdder, sourceFile, declaration, type, program, host);
+        }
+    }
+    if (needParens)
+        changes.insertNodeAfter(sourceFile, last(containingFunction.parameters), createToken(SyntaxKind.CloseParenToken));
+}
+// Na tag, aqui vinham o `annotateThis` e o `annotateJSDocThis`, do `this` de uma função, e o `annotateSetAccessor`, do
+// parâmetro de um setter (CK-02).
+function annotate(changes, importAdder, sourceFile, declaration, type, program, host) {
+    const typeNode = getTypeNodeIfAccessible(type, declaration, program, host);
+    if (typeNode) {
+        // Na tag, num arquivo JavaScript, o tipo ia para uma tag `@type` ou `@return` do JSDoc (CK-03).
+        if (!tryReplaceImportTypeNodeWithAutoImport(typeNode, declaration, type, sourceFile, changes, importAdder, languageVersion)) {
+            changes.tryInsertTypeAnnotation(sourceFile, declaration, typeNode);
+        }
+    }
+}
+function tryReplaceImportTypeNodeWithAutoImport(typeNode, declaration, type, sourceFile, changes, importAdder, scriptTarget) {
+    const importableReference = tryGetAutoImportableReferenceFromImportTypeNode(typeNode, type, scriptTarget);
+    if (importableReference && changes.tryInsertTypeAnnotation(sourceFile, declaration, importableReference.typeReference)) {
+        forEach(importableReference.symbols, s => importAdder.addImportFromExportedSymbol(s, /*usageIsTypeOnly*/ true));
+        return true;
+    }
+    return false;
+}
+// Na tag, aqui vinham o `annotateJSDocParameters`, o `addJSDocTags`, o `getJsDocNodeForArrowFunction` e o
+// `tryMergeJsdocTags`, que escreviam as tags do JSDoc de um arquivo JavaScript (CK-03).
+// Na tag, o token podia ser também a palavra `constructor` (CK-02).
+function getReferences(token, program, cancellationToken) {
+    // Position shouldn't matter since token is not a SourceFile.
+    return mapDefined(FindAllReferences.getReferenceEntriesForNode(-1, token, program, program.getSourceFiles(), cancellationToken), entry => entry.kind !== 0 /* FindAllReferences.EntryKind.Span */ ? tryCast(entry.node, isIdentifier) : undefined);
+}
+// Na tag, o token podia ser também o nome `#private` (CK-02).
+function inferTypeForVariableFromUsage(token, program, cancellationToken) {
+    const references = getReferences(token, program, cancellationToken);
+    return inferTypeFromReferences(program, references, cancellationToken).single();
+}
+// Na tag, recebia também o arquivo, que só repassava.
+function inferTypeForParametersFromUsage(func, program, cancellationToken) {
+    const references = getFunctionReferences(func, program, cancellationToken);
+    return references && inferTypeFromReferences(program, references, cancellationToken).parameters(func) ||
+        func.parameters.map(p => ({
+            declaration: p,
+            type: isIdentifier(p.name) ? inferTypeForVariableFromUsage(p.name, program, cancellationToken) : program.getTypeChecker().getAnyType()
+        }));
+}
+// Na tag, recebia também o arquivo, que só a palavra `constructor` pedia (CK-02).
+function getFunctionReferences(containingFunction, program, cancellationToken) {
+    let searchToken;
+    // Na tag, também o construtor, a function expression, a `function` declarada e o método (CK-02).
+    switch (containingFunction.kind) {
+        case SyntaxKind.ArrowFunction:
+            const parent = containingFunction.parent;
+            searchToken = isVariableDeclaration(parent) && isIdentifier(parent.name) ?
+                parent.name :
+                containingFunction.name;
+            break;
+    }
+    if (!searchToken) {
+        return undefined;
+    }
+    return getReferences(searchToken, program, cancellationToken);
+}
+function inferTypeFromReferences(program, references, cancellationToken) {
+    const checker = program.getTypeChecker();
+    const builtinConstructors = {
+        string: () => checker.getStringType(),
+        number: () => checker.getNumberType(),
+        Array: t => checker.createArrayType(t),
+        Promise: t => checker.createPromiseType(t),
+    };
+    const builtins = [
+        checker.getStringType(),
+        checker.getNumberType(),
+        checker.createArrayType(checker.getAnyType()),
+        checker.createPromiseType(checker.getAnyType()),
+    ];
+    // Na tag, também o tipo do `this` (CK-02).
+    return {
+        single,
+        parameters,
+    };
+    function createEmptyUsage() {
+        return {
+            isNumber: undefined,
+            isString: undefined,
+            isNumberOrString: undefined,
+            candidateTypes: undefined,
+            properties: undefined,
+            calls: undefined,
+            numberIndex: undefined,
+            stringIndex: undefined,
+            inferredTypes: undefined,
+        };
+    }
+    function combineUsages(usages) {
+        const combinedProperties = createUnderscoreEscapedMap();
+        for (const u of usages) {
+            if (u.properties) {
+                u.properties.forEach((p, name) => {
+                    if (!combinedProperties.has(name)) {
+                        combinedProperties.set(name, []);
+                    }
+                    combinedProperties.get(name).push(p);
+                });
+            }
+        }
+        const properties = createUnderscoreEscapedMap();
+        combinedProperties.forEach((ps, name) => {
+            properties.set(name, combineUsages(ps));
+        });
+        return {
+            isNumber: usages.some(u => u.isNumber),
+            isString: usages.some(u => u.isString),
+            isNumberOrString: usages.some(u => u.isNumberOrString),
+            candidateTypes: flatMap(usages, u => u.candidateTypes),
+            properties,
+            calls: flatMap(usages, u => u.calls),
+            numberIndex: forEach(usages, u => u.numberIndex),
+            stringIndex: forEach(usages, u => u.stringIndex),
+            inferredTypes: undefined, // clear type cache
+        };
+    }
+    function single() {
+        return combineTypes(inferTypesFromReferencesSingle(references));
+    }
+    function parameters(declaration) {
+        if (references.length === 0 || !declaration.parameters) {
+            return undefined;
+        }
+        const usage = createEmptyUsage();
+        for (const reference of references) {
+            cancellationToken.throwIfCancellationRequested();
+            calculateUsageOfNode(reference, usage);
+        }
+        // Na tag, primeiro as chamadas com `new` (CK-02).
+        const calls = [...usage.calls || []];
+        return declaration.parameters.map((parameter, parameterIndex) => {
+            const types = [];
+            const isRest = isRestParameter(parameter);
+            for (const call of calls) {
+                if (call.argumentTypes.length <= parameterIndex) {
+                    // Na tag, num arquivo JavaScript, o parâmetro ficava também opcional (CK-03).
+                    types.push(checker.getUndefinedType());
+                }
+                else if (isRest) {
+                    for (let i = parameterIndex; i < call.argumentTypes.length; i++) {
+                        types.push(checker.getBaseTypeOfLiteralType(call.argumentTypes[i]));
+                    }
+                }
+                else {
+                    types.push(checker.getBaseTypeOfLiteralType(call.argumentTypes[parameterIndex]));
+                }
+            }
+            if (isIdentifier(parameter.name)) {
+                const inferred = inferTypesFromReferencesSingle(getReferences(parameter.name, program, cancellationToken));
+                types.push(...(isRest ? mapDefined(inferred, checker.getElementTypeOfArrayType) : inferred));
+            }
+            const type = combineTypes(types);
+            return {
+                type: isRest ? checker.createArrayType(type) : type,
+                declaration: parameter
+            };
+        });
+    }
+    // Na tag, aqui vinha o `thisParameter`, o tipo do `this` pelos usos (CK-02).
+    function inferTypesFromReferencesSingle(references) {
+        const usage = createEmptyUsage();
+        for (const reference of references) {
+            cancellationToken.throwIfCancellationRequested();
+            calculateUsageOfNode(reference, usage);
+        }
+        return inferTypes(usage);
+    }
+    function calculateUsageOfNode(node, usage) {
+        while (isRightSideOfQualifiedNameOrPropertyAccess(node)) {
+            node = node.parent;
+        }
+        switch (node.parent.kind) {
+            case SyntaxKind.ExpressionStatement:
+                inferTypeFromExpressionStatement(node, usage);
+                break;
+            case SyntaxKind.PostfixUnaryExpression:
+                usage.isNumber = true;
+                break;
+            case SyntaxKind.PrefixUnaryExpression:
+                inferTypeFromPrefixUnaryExpression(node.parent, usage);
+                break;
+            case SyntaxKind.BinaryExpression:
+                inferTypeFromBinaryExpression(node, node.parent, usage);
+                break;
+            case SyntaxKind.CaseClause:
+            case SyntaxKind.DefaultClause:
+                inferTypeFromSwitchStatementLabel(node.parent, usage);
+                break;
+            // Na tag, também a chamada com `new` (CK-02).
+            case SyntaxKind.CallExpression:
+                if (node.parent.expression === node) {
+                    inferTypeFromCallExpression(node.parent, usage);
+                }
+                else {
+                    inferTypeFromContextualType(node, usage);
+                }
+                break;
+            case SyntaxKind.PropertyAccessExpression:
+                inferTypeFromPropertyAccessExpression(node.parent, usage);
+                break;
+            case SyntaxKind.ElementAccessExpression:
+                inferTypeFromPropertyElementExpression(node.parent, node, usage);
+                break;
+            case SyntaxKind.PropertyAssignment:
+            case SyntaxKind.ShorthandPropertyAssignment:
+                // Na tag, o tipo do object literal ia para os candidatos ao tipo do `this` de quem o usava (CK-02).
+                break;
+            // Na tag, também a propriedade de classe, que dava o tipo do `this` (CK-02).
+            case SyntaxKind.VariableDeclaration: {
+                const { name, initializer } = node.parent;
+                if (node === name) {
+                    if (initializer) { // This can happen for `let x = null;` which still has an implicit-any error.
+                        addCandidateType(usage, checker.getTypeAtLocation(initializer));
+                    }
+                    break;
+                }
+            }
+            // falls through
+            default:
+                return inferTypeFromContextualType(node, usage);
+        }
+    }
+    function inferTypeFromContextualType(node, usage) {
+        if (isExpressionNode(node)) {
+            addCandidateType(usage, checker.getContextualType(node));
+        }
+    }
+    function inferTypeFromExpressionStatement(node, usage) {
+        addCandidateType(usage, isCallExpression(node) ? checker.getVoidType() : checker.getAnyType());
+    }
+    function inferTypeFromPrefixUnaryExpression(node, usage) {
+        switch (node.operator) {
+            case SyntaxKind.PlusPlusToken:
+            case SyntaxKind.MinusMinusToken:
+            case SyntaxKind.MinusToken:
+            case SyntaxKind.TildeToken:
+                usage.isNumber = true;
+                break;
+            case SyntaxKind.PlusToken:
+                usage.isNumberOrString = true;
+                break;
+            // case SyntaxKind.ExclamationToken:
+            // no inferences here;
+        }
+    }
+    function inferTypeFromBinaryExpression(node, parent, usage) {
+        switch (parent.operatorToken.kind) {
+            // ExponentiationOperator
+            case SyntaxKind.AsteriskAsteriskToken:
+            // MultiplicativeOperator
+            // falls through
+            case SyntaxKind.AsteriskToken:
+            case SyntaxKind.SlashToken:
+            case SyntaxKind.PercentToken:
+            // ShiftOperator
+            // falls through
+            case SyntaxKind.LessThanLessThanToken:
+            case SyntaxKind.GreaterThanGreaterThanToken:
+            case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
+            // BitwiseOperator
+            // falls through
+            case SyntaxKind.AmpersandToken:
+            case SyntaxKind.BarToken:
+            case SyntaxKind.CaretToken:
+            // CompoundAssignmentOperator
+            // falls through
+            case SyntaxKind.MinusEqualsToken:
+            case SyntaxKind.AsteriskAsteriskEqualsToken:
+            case SyntaxKind.AsteriskEqualsToken:
+            case SyntaxKind.SlashEqualsToken:
+            case SyntaxKind.PercentEqualsToken:
+            case SyntaxKind.AmpersandEqualsToken:
+            case SyntaxKind.BarEqualsToken:
+            case SyntaxKind.CaretEqualsToken:
+            case SyntaxKind.LessThanLessThanEqualsToken:
+            case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
+            case SyntaxKind.GreaterThanGreaterThanEqualsToken:
+            // AdditiveOperator
+            // falls through
+            case SyntaxKind.MinusToken:
+            // RelationalOperator
+            // falls through
+            case SyntaxKind.LessThanToken:
+            case SyntaxKind.LessThanEqualsToken:
+            case SyntaxKind.GreaterThanToken:
+            case SyntaxKind.GreaterThanEqualsToken:
+                // Na tag, o operando de um enum dava o tipo do enum (CK-02).
+                usage.isNumber = true;
+                break;
+            case SyntaxKind.PlusEqualsToken:
+            case SyntaxKind.PlusToken:
+                const otherOperandType = checker.getTypeAtLocation(parent.left === node ? parent.right : parent.left);
+                // Na tag, primeiro o operando de um enum, que dava o tipo do enum (CK-02).
+                if (otherOperandType.flags & TypeFlags.NumberLike) {
+                    usage.isNumber = true;
+                }
+                else if (otherOperandType.flags & TypeFlags.StringLike) {
+                    usage.isString = true;
+                }
+                else if (otherOperandType.flags & TypeFlags.Any) {
+                    // do nothing, maybe we'll learn something elsewhere
+                }
+                else {
+                    usage.isNumberOrString = true;
+                }
+                break;
+            //  AssignmentOperators
+            // Na tag, também o `===` e o `!==`, que a Linguagem não tem (CK-70).
+            case SyntaxKind.EqualsToken:
+            case SyntaxKind.EqualsEqualsToken:
+            case SyntaxKind.ExclamationEqualsToken:
+                addCandidateType(usage, checker.getTypeAtLocation(parent.left === node ? parent.right : parent.left));
+                break;
+            case SyntaxKind.InKeyword:
+                if (node === parent.left) {
+                    usage.isString = true;
+                }
+                break;
+            // LogicalOperator Or NullishCoalescing
+            case SyntaxKind.BarBarToken:
+            case SyntaxKind.QuestionQuestionToken:
+                if (node === parent.left &&
+                    (node.parent.parent.kind === SyntaxKind.VariableDeclaration || isAssignmentExpression(node.parent.parent, /*excludeCompoundAssignment*/ true))) {
+                    // var x = x || {};
+                    // TODO: use getFalsyflagsOfType
+                    addCandidateType(usage, checker.getTypeAtLocation(parent.right));
+                }
+                break;
+            // Na tag, também a vírgula e o `instanceof`, de que nada se infere (CK-02).
+            case SyntaxKind.AmpersandAmpersandToken:
+                // nothing to infer here
+                break;
+        }
+    }
+    function inferTypeFromSwitchStatementLabel(parent, usage) {
+        addCandidateType(usage, checker.getTypeAtLocation(parent.parent.parent.expression));
+    }
+    // Na tag, também a chamada com `new` (CK-02).
+    function inferTypeFromCallExpression(parent, usage) {
+        const call = {
+            argumentTypes: [],
+            return_: createEmptyUsage()
+        };
+        if (parent.arguments) {
+            for (const argument of parent.arguments) {
+                call.argumentTypes.push(checker.getTypeAtLocation(argument));
+            }
+        }
+        calculateUsageOfNode(parent, call.return_);
+        (usage.calls || (usage.calls = [])).push(call);
+    }
+    function inferTypeFromPropertyAccessExpression(parent, usage) {
+        const name = escapeLeadingUnderscores(parent.name.text);
+        if (!usage.properties) {
+            usage.properties = createUnderscoreEscapedMap();
+        }
+        const propertyUsage = usage.properties.get(name) || createEmptyUsage();
+        calculateUsageOfNode(parent, propertyUsage);
+        usage.properties.set(name, propertyUsage);
+    }
+    function inferTypeFromPropertyElementExpression(parent, node, usage) {
+        if (node === parent.argumentExpression) {
+            usage.isNumberOrString = true;
+            return;
+        }
+        else {
+            const indexType = checker.getTypeAtLocation(parent.argumentExpression);
+            const indexUsage = createEmptyUsage();
+            calculateUsageOfNode(parent, indexUsage);
+            if (indexType.flags & TypeFlags.NumberLike) {
+                usage.numberIndex = indexUsage;
+            }
+            else {
+                usage.stringIndex = indexUsage;
+            }
+        }
+    }
+    function removeLowPriorityInferences(inferences, priorities) {
+        const toRemove = [];
+        for (const i of inferences) {
+            for (const { high, low } of priorities) {
+                if (high(i)) {
+                    Debug.assert(!low(i), "Priority can't have both low and high");
+                    toRemove.push(low);
+                }
+            }
+        }
+        return inferences.filter(i => toRemove.every(f => !f(i)));
+    }
+    function combineFromUsage(usage) {
+        return combineTypes(inferTypes(usage));
+    }
+    function combineTypes(inferences) {
+        if (!inferences.length)
+            return checker.getAnyType();
+        // 1. string or number individually override string | number
+        // 2. non-any, non-void overrides any or void
+        // 3. non-nullable, non-any, non-void, non-anonymous overrides anonymous types
+        const stringNumber = checker.getUnionType([checker.getStringType(), checker.getNumberType()]);
+        const priorities = [
+            {
+                high: t => t === checker.getStringType() || t === checker.getNumberType(),
+                low: t => t === stringNumber
+            },
+            {
+                high: t => !(t.flags & (TypeFlags.Any | TypeFlags.Void)),
+                low: t => !!(t.flags & (TypeFlags.Any | TypeFlags.Void))
+            },
+            {
+                high: t => !(t.flags & (TypeFlags.Nullable | TypeFlags.Any | TypeFlags.Void)) && !(getObjectFlags(t) & ObjectFlags.Anonymous),
+                low: t => !!(getObjectFlags(t) & ObjectFlags.Anonymous)
+            }
+        ];
+        let good = removeLowPriorityInferences(inferences, priorities);
+        const anons = good.filter(i => getObjectFlags(i) & ObjectFlags.Anonymous);
+        if (anons.length) {
+            good = good.filter(i => !(getObjectFlags(i) & ObjectFlags.Anonymous));
+            good.push(combineAnonymousTypes(anons));
+        }
+        return checker.getWidenedType(checker.getUnionType(good.map(checker.getBaseTypeOfLiteralType), UnionReduction.Subtype));
+    }
+    // Na tag, também as construct signatures dos tipos (CK-02).
+    function combineAnonymousTypes(anons) {
+        if (anons.length === 1) {
+            return anons[0];
+        }
+        const calls = [];
+        const stringIndices = [];
+        const numberIndices = [];
+        let stringIndexReadonly = false;
+        let numberIndexReadonly = false;
+        const props = createMultiMap();
+        for (const anon of anons) {
+            for (const p of checker.getPropertiesOfType(anon)) {
+                props.add(p.name, checker.getTypeOfSymbolAtLocation(p, p.valueDeclaration));
+            }
+            calls.push(...checker.getSignaturesOfType(anon));
+            if (anon.stringIndexInfo) {
+                stringIndices.push(anon.stringIndexInfo.type);
+                stringIndexReadonly = stringIndexReadonly || anon.stringIndexInfo.isReadonly;
+            }
+            if (anon.numberIndexInfo) {
+                numberIndices.push(anon.numberIndexInfo.type);
+                numberIndexReadonly = numberIndexReadonly || anon.numberIndexInfo.isReadonly;
+            }
+        }
+        const members = mapEntries(props, (name, types) => {
+            const isOptional = types.length < anons.length ? SymbolFlags.Optional : 0;
+            const s = checker.createSymbol(SymbolFlags.Property | isOptional, name);
+            s.type = checker.getUnionType(types);
+            return [name, s];
+        });
+        return checker.createAnonymousType(anons[0].symbol, members, calls, stringIndices.length ? checker.createIndexInfo(checker.getUnionType(stringIndices), stringIndexReadonly) : undefined, numberIndices.length ? checker.createIndexInfo(checker.getUnionType(numberIndices), numberIndexReadonly) : undefined);
+    }
+    function inferTypes(usage) {
+        const types = [];
+        if (usage.isNumber) {
+            types.push(checker.getNumberType());
+        }
+        if (usage.isString) {
+            types.push(checker.getStringType());
+        }
+        if (usage.isNumberOrString) {
+            types.push(checker.getUnionType([checker.getStringType(), checker.getNumberType()]));
+        }
+        if (usage.numberIndex) {
+            types.push(checker.createArrayType(combineFromUsage(usage.numberIndex)));
+        }
+        // Na tag, também as chamadas com `new` (CK-02).
+        if (usage.properties?.size || usage.calls?.length || usage.stringIndex) {
+            types.push(inferStructuralType(usage));
+        }
+        types.push(...(usage.candidateTypes || []).map(t => checker.getBaseTypeOfLiteralType(t)));
+        types.push(...inferNamedTypesFromProperties(usage));
+        return types;
+    }
+    // Na tag, também a construct signature das chamadas com `new` (CK-02).
+    function inferStructuralType(usage) {
+        const members = createUnderscoreEscapedMap();
+        if (usage.properties) {
+            usage.properties.forEach((u, name) => {
+                const symbol = checker.createSymbol(SymbolFlags.Property, name);
+                symbol.type = combineFromUsage(u);
+                members.set(name, symbol);
+            });
+        }
+        const callSignatures = usage.calls ? [getSignatureFromCalls(usage.calls)] : [];
+        const stringIndexInfo = usage.stringIndex && checker.createIndexInfo(combineFromUsage(usage.stringIndex), /*isReadonly*/ false);
+        return checker.createAnonymousType(/*symbol*/ undefined, members, callSignatures, stringIndexInfo, /*numberIndexInfo*/ undefined);
+    }
+    function inferNamedTypesFromProperties(usage) {
+        if (!usage.properties || !usage.properties.size)
+            return [];
+        const types = builtins.filter(t => allPropertiesAreAssignableToUsage(t, usage));
+        if (0 < types.length && types.length < 3) {
+            return types.map(t => inferInstantiationFromUsage(t, usage));
+        }
+        return [];
+    }
+    function allPropertiesAreAssignableToUsage(type, usage) {
+        if (!usage.properties)
+            return false;
+        return !forEachEntry(usage.properties, (propUsage, name) => {
+            const source = checker.getTypeOfPropertyOfType(type, name);
+            if (!source) {
+                return true;
+            }
+            if (propUsage.calls) {
+                const sigs = checker.getSignaturesOfType(source);
+                return !sigs.length || !checker.isTypeAssignableTo(source, getFunctionFromCalls(propUsage.calls));
+            }
+            else {
+                return !checker.isTypeAssignableTo(source, combineFromUsage(propUsage));
+            }
+        });
+    }
+    /**
+     * inference is limited to
+     * 1. generic types with a single parameter
+     * 2. inference to/from calls with a single signature
+     */
+    function inferInstantiationFromUsage(type, usage) {
+        if (!(getObjectFlags(type) & ObjectFlags.Reference) || !usage.properties) {
+            return type;
+        }
+        const generic = type.target;
+        const singleTypeParameter = singleOrUndefined(generic.typeParameters);
+        if (!singleTypeParameter)
+            return type;
+        const types = [];
+        usage.properties.forEach((propUsage, name) => {
+            const genericPropertyType = checker.getTypeOfPropertyOfType(generic, name);
+            Debug.assert(!!genericPropertyType, "generic should have all the properties of its reference.");
+            types.push(...inferTypeParameters(genericPropertyType, combineFromUsage(propUsage), singleTypeParameter));
+        });
+        return builtinConstructors[type.symbol.escapedName](combineTypes(types));
+    }
+    function inferTypeParameters(genericType, usageType, typeParameter) {
+        if (genericType === typeParameter) {
+            return [usageType];
+        }
+        else if (genericType.flags & TypeFlags.UnionOrIntersection) {
+            return flatMap(genericType.types, t => inferTypeParameters(t, usageType, typeParameter));
+        }
+        else if (getObjectFlags(genericType) & ObjectFlags.Reference && getObjectFlags(usageType) & ObjectFlags.Reference) {
+            // this is wrong because we need a reference to the targetType to, so we can check that it's also a reference
+            const genericArgs = checker.getTypeArguments(genericType);
+            const usageArgs = checker.getTypeArguments(usageType);
+            const types = [];
+            if (genericArgs && usageArgs) {
+                for (let i = 0; i < genericArgs.length; i++) {
+                    if (usageArgs[i]) {
+                        types.push(...inferTypeParameters(genericArgs[i], usageArgs[i], typeParameter));
+                    }
+                }
+            }
+            return types;
+        }
+        const genericSigs = checker.getSignaturesOfType(genericType);
+        const usageSigs = checker.getSignaturesOfType(usageType);
+        if (genericSigs.length === 1 && usageSigs.length === 1) {
+            return inferFromSignatures(genericSigs[0], usageSigs[0], typeParameter);
+        }
+        return [];
+    }
+    function inferFromSignatures(genericSig, usageSig, typeParameter) {
+        const types = [];
+        for (let i = 0; i < genericSig.parameters.length; i++) {
+            const genericParam = genericSig.parameters[i];
+            const usageParam = usageSig.parameters[i];
+            const isRest = genericSig.declaration && isRestParameter(genericSig.declaration.parameters[i]);
+            if (!usageParam) {
+                break;
+            }
+            let genericParamType = checker.getTypeOfSymbolAtLocation(genericParam, genericParam.valueDeclaration);
+            const elementType = isRest && checker.getElementTypeOfArrayType(genericParamType);
+            if (elementType) {
+                genericParamType = elementType;
+            }
+            const targetType = usageParam.type || checker.getTypeOfSymbolAtLocation(usageParam, usageParam.valueDeclaration);
+            types.push(...inferTypeParameters(genericParamType, targetType, typeParameter));
+        }
+        const genericReturn = checker.getReturnTypeOfSignature(genericSig);
+        const usageReturn = checker.getReturnTypeOfSignature(usageSig);
+        types.push(...inferTypeParameters(genericReturn, usageReturn, typeParameter));
+        return types;
+    }
+    function getFunctionFromCalls(calls) {
+        return checker.createAnonymousType(/*symbol*/ undefined, createSymbolTable(), [getSignatureFromCalls(calls)], /*stringIndexInfo*/ undefined, /*numberIndexInfo*/ undefined);
+    }
+    function getSignatureFromCalls(calls) {
+        const parameters = [];
+        const length = Math.max(...calls.map(c => c.argumentTypes.length));
+        for (let i = 0; i < length; i++) {
+            const symbol = checker.createSymbol(SymbolFlags.FunctionScopedVariable, escapeLeadingUnderscores(`arg${i}`));
+            symbol.type = combineTypes(calls.map(call => call.argumentTypes[i] || checker.getUndefinedType()));
+            if (calls.some(call => call.argumentTypes[i] === undefined)) {
+                symbol.flags |= SymbolFlags.Optional;
+            }
+            parameters.push(symbol);
+        }
+        const returnType = combineFromUsage(combineUsages(calls.map(call => call.return_)));
+        return checker.createSignature(/*declaration*/ undefined, /*typeParameters*/ undefined, parameters, returnType, /*typePredicate*/ undefined, length, SignatureFlags.None);
+    }
+    function addCandidateType(usage, type) {
+        if (type && !(type.flags & TypeFlags.Any) && !(type.flags & TypeFlags.Never)) {
+            (usage.candidateTypes || (usage.candidateTypes = [])).push(type);
+        }
+    }
+    // Na tag, aqui vinha o `addCandidateThisType` (CK-02).
+}