@artel/artc 0.6.25254 → 0.6.25256

package/build/types/analysis/BaseExpressionMeaning.d.ts

@@ -1,21 +1,13 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
+import { AccessedFunction } from './AccessedFunction.js';
 import { Analyzer } from './Analyzer.js';
-/**
- * "основа" не является самостоятельным выражением и может использоваться только в следующих конструкциях:
- * 1. `основа()` - в конструкторе для вызова базового конструктора или в методе для вызова базового метода.
- * 2. `основа.поле` (`основа.метод`) - в любом выражении в контексте типа, имеющего базовый тип.
- * 3. `основа[]` - аналогично п. 2.
- * 4. `основа^` - аналогично п. 2.
- * 5. `(основа как БазовыйАспект).поле`, `(основа как БазовыйАспект)[]`, `(основа как БазовыйАспект)^` - для доступа к
- *    реализации по умолчанию члена базового аспекта.
- */
-export declare class Resolver {
+export declare class FirstStageResolver {
     private readonly _analyzer;
     private readonly _node;
     constructor(analyzer: Analyzer, node: tree.BaseExpression);
-    resolve(): ResolutionsResult;
+    resolve(): FirstStageResolutionsResult;
     private resolveBaseConstructorOrMethodAccess;
     private resolveBaseConstructorAccess;
     private resolveBaseMethodAccess;
@@ -25,11 +17,29 @@ export declare class Resolver {
     private getBaseOrAliasedType;
     private getContainingTypeMemberDeclaration;
 }
-export declare class ResolutionsResult {
+/**
+ * "основа" не является самостоятельным выражением и может использоваться только в следующих конструкциях:
+ * 1. `основа()` - в конструкторе для вызова базового конструктора или в методе для вызова базового метода.
+ * 2. `основа.поле` (`основа.метод`) - в любом выражении в контексте типа, имеющего базовый тип.
+ * 3. `основа[]` - аналогично п. 2.
+ * 4. `основа^` - аналогично п. 2.
+ * 5. `(основа как БазовыйАспект).поле`, `(основа как БазовыйАспект)[]`, `(основа как БазовыйАспект)^` - для доступа к
+ *    реализации по умолчанию члена базового аспекта.
+ */
+export declare class SecondStageResolver {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _firstStageResolutionResult;
+    constructor(analyzer: Analyzer, node: tree.BaseExpression, firstStageResolutionResult: FirstStageResolutionsResult);
+    resolve(): ResolutionResult;
+    private resolveOverriddenMethodAccess;
+    private resolveOverriddenOperatorAccess;
+}
+export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly diagnostics?: readonly Diagnostic[] | undefined;
     constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
-    static unresolved(diagnostics?: readonly Diagnostic[]): ResolutionsResult;
+    static unresolved(diagnostics?: readonly Diagnostic[]): ResolutionResult;
 }
 export type Meaning = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | Meaning_overriddenMethodAccess | Meaning_overriddenOperatorAccess | Meaning_unresolved;
 declare class Meaning_baseObjectAccess {
@@ -50,6 +60,7 @@ declare class Meaning_baseConstructorAccess {
     readonly suitableConstructors: readonly types.Constructor[];
     readonly kind = "base-constructor-access";
     get singleSuitableConstructor(): types.Constructor | undefined;
+    get singleConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
@@ -61,9 +72,9 @@ declare class Meaning_baseConstructorAccess {
     type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
 }
 declare class Meaning_overriddenMethodAccess {
-    readonly method: types.Method;
+    readonly method: AccessedFunction;
     readonly kind = "overridden-method-access";
-    constructor(method: types.Method);
+    constructor(method: AccessedFunction);
 }
 declare class Meaning_overriddenOperatorAccess {
     readonly operator: types.Operator;
@@ -73,4 +84,21 @@ declare class Meaning_overriddenOperatorAccess {
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
+export declare class FirstStageResolutionsResult {
+    readonly meaning: MeaningStage1;
+    readonly diagnostics?: readonly Diagnostic[] | undefined;
+    constructor(meaning: MeaningStage1, diagnostics?: readonly Diagnostic[] | undefined);
+    static unresolved(diagnostics?: readonly Diagnostic[]): FirstStageResolutionsResult;
+}
+export type MeaningStage1 = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | MeaningStage1_overriddenMethodAccess | MeaningStage1_overriddenOperatorAccess | Meaning_unresolved;
+declare class MeaningStage1_overriddenMethodAccess {
+    readonly method: types.Method;
+    readonly kind = "overridden-method-access";
+    constructor(method: types.Method);
+}
+declare class MeaningStage1_overriddenOperatorAccess {
+    readonly operator: types.Operator;
+    readonly kind = "overridden-operator-access";
+    constructor(operator: types.Operator);
+}
 export {};

package/build/types/analysis/CallExpressionMeaning.d.ts

@@ -1,36 +1,55 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { CallExpression } from '../tree/index.js';
+import { NamedTypeEntity } from '../entities/index.js';
+import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
-import { AccessedFunction } from './AccessedFunction.js';
-import { Analyzer } from './index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
+import { Analyzer, ExpressionAnalysisOptions } from './index.js';
 export declare class Resolver {
     private readonly _analyzer;
     private readonly _node;
-    constructor(_analyzer: Analyzer, _node: CallExpression);
+    private readonly _analysisOptions;
+    constructor(_analyzer: Analyzer, _node: tree.CallExpression, _analysisOptions: ExpressionAnalysisOptions | undefined);
     private get callee();
-    resolve(): Meaning;
-    resolveType(meaning: Meaning | undefined): types.Type;
-    private resolveConstructorCallExpressionMeaning;
+    resolve(): ResolutionResult;
+    private checkExpressionDenotesType;
+    private checkExpressionDenotesFunction;
+    private checkExpressionDenotesOperator;
+    private resolveFunctionCallExpression;
+    private resolveOperatorCallExpression;
+    private resolveConstructorCallExpression;
+    private resolveObjectFunctionCallExpression;
     private getNodeForDiagnostics;
-    private getTypeFromMeaning;
+}
+export declare class ResolutionResult {
+    readonly meaning: Meaning;
+    readonly diagnostics?: readonly Diagnostic[] | undefined;
+    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
+    static unresolved(diagnostics: readonly Diagnostic[] | undefined): ResolutionResult;
 }
 export type Meaning = Meaning_functionCall | Meaning_operatorCall | Meaning_objectFunctionCall | Meaning_constructorCall | Meaning_unresolved;
-declare class Meaning_functionCall {
-    readonly func: AccessedFunction;
+export declare class Meaning_functionCall {
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
+    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
     readonly kind = "function-call";
-    constructor(func: AccessedFunction);
+    get singleSuitableFunction(): AccessedFunction | undefined;
+    get singleFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
 }
-declare class Meaning_operatorCall {
-    readonly operator: types.Operator;
+export declare class Meaning_operatorCall {
+    readonly candidates: readonly types.Operator[];
+    readonly suitableOperators: readonly types.Operator[];
     readonly kind = "operator-call";
-    constructor(operator: types.Operator);
+    get singleSuitableOperator(): types.Operator | undefined;
+    get singleOperator(): types.Operator | undefined;
+    constructor(candidates: readonly types.Operator[], suitableOperators: readonly types.Operator[]);
 }
-declare class Meaning_objectFunctionCall {
+export declare class Meaning_objectFunctionCall {
     readonly type: types.FunctionType;
     readonly kind = "object-function-call";
     constructor(type: types.FunctionType);
 }
-declare class Meaning_constructorCall {
+export declare class Meaning_constructorCall {
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
      *
@@ -38,11 +57,14 @@ declare class Meaning_constructorCall {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    readonly type: types.Type;
+    readonly type: types.Type | undefined;
+    readonly typeEntity: NamedTypeEntity | undefined;
     readonly candidates: readonly types.Constructor[];
     readonly suitableConstructors: readonly types.Constructor[];
+    readonly singleNotSuitableSubstitutedCandidate: types.Constructor | undefined;
     readonly kind = "constructor-call";
     get singleSuitableConstructor(): types.Constructor | undefined;
+    get singleConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
@@ -51,11 +73,8 @@ declare class Meaning_constructorCall {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
+    type: types.Type | undefined, typeEntity: NamedTypeEntity | undefined, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[], singleNotSuitableSubstitutedCandidate: types.Constructor | undefined);
 }
-declare class Meaning_unresolved {
-    readonly diagnostics: readonly Diagnostic[];
+export declare class Meaning_unresolved {
     readonly kind = "unresolved";
-    constructor(diagnostics: readonly Diagnostic[]);
 }
-export {};

package/build/types/analysis/ConstructorCallResolver.d.ts

@@ -0,0 +1,22 @@
+import { PackageLocale } from '../common/index.js';
+import { DiagnosticAcceptorWithArgumentFactory } from '../diagnostic/Diagnostic.js';
+import { IEntityHidingMatcher, NamedTypeEntity } from '../entities/index.js';
+import * as tree from '../tree/index.js';
+import * as types from '../types/index.js';
+import { Analyzer, ExpressionAnalysisOptions } from './Analyzer.js';
+import { SemanticContext } from './semantic-context/SemanticContext.js';
+export declare class Resolver {
+    static resolve(analyzer: Analyzer, candidates: readonly types.Constructor[], argumentList: tree.ArgumentList | undefined, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): readonly types.Constructor[];
+    static resolveByNamedTypes(analyzer: Analyzer, typeEntities: readonly NamedTypeEntity[], argumentList: tree.ArgumentList | undefined, typeArgumentClause: tree.TypeArgumentClause | undefined, analysisOptions: ExpressionAnalysisOptions, locale: PackageLocale, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): ResolutionResult;
+    private static typeCanBeConstructed;
+}
+export declare class ResolutionResult {
+    readonly candidates: readonly types.Constructor[];
+    readonly suitableConstructors: readonly types.Constructor[];
+    readonly typeEntity: NamedTypeEntity | undefined;
+    readonly type: types.Type | undefined;
+    readonly singleNotSuitableSubstitutedCandidate: types.Constructor | undefined;
+    private static _empty;
+    static get empty(): ResolutionResult;
+    constructor(candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[], typeEntity: NamedTypeEntity | undefined, type: types.Type | undefined, singleNotSuitableSubstitutedCandidate: types.Constructor | undefined);
+}

package/build/types/analysis/DiagnosticArgumentFactory.d.ts

@@ -1,5 +1,6 @@
 import { PackageDialect, PackageLocale } from '../common/index.js';
 import { Entity } from '../entities/index.js';
+import { SourceFile } from '../project/index.js';
 import * as types from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
 import { Analyzer } from './Analyzer.js';
@@ -9,7 +10,8 @@ export declare class DiagnosticArgumentFactory {
     readonly locale: PackageLocale;
     readonly dialect: PackageDialect;
     private readonly _analyzer;
-    constructor(analyzer: Analyzer, locale: PackageLocale, dialect: PackageDialect);
+    private readonly _contextualSourceFile;
+    constructor(analyzer: Analyzer, locale: PackageLocale, dialect: PackageDialect, sourceFile: SourceFile | undefined);
     createDisplayableEntity(entity: Entity): DisplayableEntity;
     createDisplayableAccessedFunction(accessedFunction: AccessedFunction): DisplayableAccessedFunction;
     createDisplayableTypeMember(member: types.TypeMember): DisplayableTypeMember;

package/build/types/analysis/DiagnosticCollector.d.ts

@@ -12,8 +12,10 @@ export declare class DiagnosticCollector {
     private readonly _diagnosticAcceptor;
     private _namedDeclarationsUsageMap;
     private readonly _modifierValidator;
+    private readonly _standardTypes;
     private get translationPackage();
     private get isInterfacePackageFile();
+    private get standardTypes();
     constructor(analyzer: Analyzer, sourceFile: project.SourceFile);
     collect(cancellationToken?: CancellationToken | undefined): Promise<Diagnostic[]>;
     private collectNodeDiagnostics;
@@ -29,6 +31,7 @@ export declare class DiagnosticCollector {
     private isNotTranslatedEntity;
     private createNotTranslatedEntitiesDiagnostic;
     private checkAllDefaultConstructorArgumentsAreNamed;
+    private checkPackageVariableDeclaration;
     private checkPackageFunctionDeclaration;
     private checkPackageVariableGetterDeclaration;
     private checkPackageVariableSetterDeclaration;
@@ -52,8 +55,7 @@ export declare class DiagnosticCollector {
     private checkLocalVariableUsedBeforeDeclaration;
     private checkLocalVariableIsUsedBeforeBeingAssigned;
     private checkMemberAccessExpression;
-    private addDiagnosticsFromMatchResult;
-    private checkExpressionTypeAssignableToTargetType;
+    private checkExpressionTypeIsAssignableToTargetType;
     private addTypeAssignabilityDiagnosticIfBothTypesResolved;
     private checkAssignmentIsValid;
     private checkAssignmentToIdentifierExpression;
@@ -66,13 +68,7 @@ export declare class DiagnosticCollector {
     private checkAssignmentToIndexedAccessExpression;
     private checkOptionalChainingIsUsedOnTheLeftSideOfAssignment;
     private checkGenericSpecializationExpression;
-    private checkFunctionSpecialization;
-    private checkTypeSpecialization;
-    private checkSpecializationOfDeclarationWithParameters;
-    /**
-     * @returns `true` если не было ошибки, иначе `false`.
-     */
-    private checkTypeArgumentCount;
+    private checkTypeArgumentTypesAreAssignableToConstraints;
     private checkParameterDeclaration;
     private checkIfVariableIsUnused;
     private checkIfNestedFunctionIsUnused;

package/build/types/analysis/DisplayableEntity.d.ts

@@ -1,15 +1,17 @@
 import { Displayable, PackageDialect, PackageLocale } from '../common/index.js';
 import { Entity } from '../entities/index.js';
+import { SourceFile } from '../project/index.js';
+import * as types from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
 import { Analyzer } from './Analyzer.js';
-import * as types from '../types/index.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 export declare class DisplayableEntity implements Displayable {
     private readonly _analyzer;
     private readonly _entity;
     private readonly _locale;
     private readonly _dialect;
-    constructor(_analyzer: Analyzer, _entity: Entity, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    private readonly _contextualSourceFile;
+    constructor(_analyzer: Analyzer, _entity: Entity, _locale: PackageLocale, _dialect: PackageDialect, _contextualSourceFile: SourceFile | undefined);
     getDisplayText(): string;
 }
 export declare class DisplayableAccessedFunction implements Displayable {
@@ -17,7 +19,8 @@ export declare class DisplayableAccessedFunction implements Displayable {
     private readonly _accessedFunction;
     private readonly _locale;
     private readonly _dialect;
-    constructor(_analyzer: Analyzer, _accessedFunction: AccessedFunction, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    private readonly _contextualSourceFile;
+    constructor(_analyzer: Analyzer, _accessedFunction: AccessedFunction, _locale: PackageLocale, _dialect: PackageDialect, _contextualSourceFile: SourceFile | undefined);
     getDisplayText(): string;
 }
 export declare class DisplayableTypeMember implements Displayable {
@@ -25,7 +28,8 @@ export declare class DisplayableTypeMember implements Displayable {
     private readonly _member;
     private readonly _locale;
     private readonly _dialect;
-    constructor(_analyzer: Analyzer, _member: types.TypeMember, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    private readonly _contextualSourceFile;
+    constructor(_analyzer: Analyzer, _member: types.TypeMember, _locale: PackageLocale, _dialect: PackageDialect, _contextualSourceFile: SourceFile | undefined);
     getDisplayText(): string;
 }
 export declare class DisplayablePackageNameTreeNode implements Displayable {
@@ -33,7 +37,8 @@ export declare class DisplayablePackageNameTreeNode implements Displayable {
     private readonly _node;
     private readonly _locale;
     private readonly _dialect;
-    constructor(_analyzer: Analyzer, _node: PackageNameTreeNode, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    private readonly _contextualSourceFile;
+    constructor(_analyzer: Analyzer, _node: PackageNameTreeNode, _locale: PackageLocale, _dialect: PackageDialect, _contextualSourceFile: SourceFile | undefined);
     getDisplayText(): string;
 }
 export declare class DisplayableType implements Displayable {
@@ -41,6 +46,7 @@ export declare class DisplayableType implements Displayable {
     private readonly _type;
     private readonly _locale;
     private readonly _dialect;
-    constructor(_analyzer: Analyzer, _type: types.Type, _locale: PackageLocale, _dialect: PackageDialect | undefined);
+    private readonly _contextualSourceFile;
+    constructor(_analyzer: Analyzer, _type: types.Type, _locale: PackageLocale, _dialect: PackageDialect, _contextualSourceFile: SourceFile | undefined);
     getDisplayText(): string;
 }

package/build/types/analysis/FunctionAccessResolver.d.ts

@@ -0,0 +1,15 @@
+import { DiagnosticAcceptorWithArgumentFactory } from '../diagnostic/Diagnostic.js';
+import * as tree from '../tree/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
+import { Analyzer, ExpressionAnalysisOptions } from './Analyzer.js';
+export declare class Resolver {
+    static resolveByCallExpression(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], node: tree.CallExpression, analysisOptions: ExpressionAnalysisOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined): ResolutionResult;
+    static resolveByCallExpressionParts(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], argumentList: tree.ArgumentList | undefined, typeArgumentClause: tree.TypeArgumentClause | undefined, analysisOptions: ExpressionAnalysisOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): ResolutionResult;
+    static resolveByTargetType(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], typeArgumentClause: tree.TypeArgumentClause | undefined, analysisOptions: ExpressionAnalysisOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): ResolutionResult;
+    private static convertProcessedSignature;
+    private static reportAmbiguousAccessDiagnostic;
+}
+export interface ResolutionResult {
+    suitableFunctions: readonly AccessedFunction[];
+    singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
+}

package/build/types/analysis/IdentifierExpressionMeaning.d.ts

@@ -3,37 +3,41 @@ import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
-import { AccessedFunction } from './AccessedFunction.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
+import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import { Analyzer, TargetTypeHint } from './index.js';
+import { Analyzer, ExpressionAnalysisOptions } from './index.js';
 import { NamedDeclaration } from './semantic-context/index.js';
-export declare class Resolver {
+export declare class FirstStageResolver {
     private readonly _semanticContext;
     private readonly _analyzer;
     private readonly _node;
-    private readonly _targetTypeHint;
     private get semanticContext();
-    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, targetTypeHint: TargetTypeHint | undefined);
-    resolve(): ResolutionResult;
+    constructor(analyzer: Analyzer, node: tree.IdentifierExpression);
+    resolve(): FirstStageResolutionResult;
     private tryResolveOperatorAccessMeaning;
-    private resolveFunctionOverload;
-    private createAccessedFunction;
+    private resolveTypeAccess;
+    private createNotSubstitutedAccessedFunction;
     private convertSyntacticAccessKind;
 }
+export declare class SecondStageResolver {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _firstStageResolutionResult;
+    private readonly _analysisOptions;
+    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, firstStageResolutionResult: FirstStageResolutionResult, analysisOptions: ExpressionAnalysisOptions | undefined);
+    resolve(): ResolutionResult;
+    private resolveTypeAccessAtCalleePosition;
+    private resolveFunctionAccess;
+    private resolveOperatorAccess;
+    private resolveNotCalledFunctionsAccess;
+}
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: Diagnostic | undefined;
-    /**
-     * Может ли измениться результат, если посчитать его с другим целевым типом?
-     */
-    readonly dependsOnTargetType: boolean;
-    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
-    /**
-     * Может ли измениться результат, если посчитать его с другим целевым типом?
-     */
-    dependsOnTargetType?: boolean);
-}
-export type Meaning = Meaning_variableAccess | Meaning_functionAccess | Meaning_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+    readonly diagnostics: readonly Diagnostic[] | undefined;
+    constructor(meaning: Meaning, diagnostics?: Diagnostic | readonly Diagnostic[]);
+}
+export type Meaning = Meaning_variableAccess | Meaning_functionAccess | Meaning_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_constructorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_variableAccess {
     readonly variable: AccessedVariable;
     readonly accessKind: AccessKind;
@@ -41,17 +45,20 @@ declare class Meaning_variableAccess {
     constructor(variable: AccessedVariable, accessKind: AccessKind);
 }
 declare class Meaning_functionAccess {
-    readonly candidates: readonly AccessedFunction[];
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
     readonly suitableFunctions: readonly AccessedFunction[];
+    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
     readonly kind = "function-access";
     get singleSuitableFunction(): AccessedFunction | undefined;
-    constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
+    get singleFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
 }
 declare class Meaning_operatorAccess {
     readonly candidates: readonly types.Operator[];
     readonly suitableOperators: readonly types.Operator[];
     readonly kind = "operator-access";
     get singleSuitableOperator(): types.Operator | undefined;
+    get singleOperator(): types.Operator | undefined;
     constructor(candidates: readonly types.Operator[], suitableOperators: readonly types.Operator[]);
 }
 declare class Meaning_packageAliasAccess {
@@ -71,6 +78,12 @@ declare class Meaning_typeAccess {
     get singleSuitableType(): types.Type | undefined;
     constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly types.Type[]);
 }
+declare class Meaning_constructorAccess {
+    readonly typeCandidates: readonly NamedTypeEntity[];
+    readonly callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall;
+    readonly kind = "constructor-access";
+    constructor(typeCandidates: readonly NamedTypeEntity[], callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall);
+}
 declare class Meaning_mixedAmbiguousAccess {
     readonly declarations: readonly NamedDeclaration[];
     readonly kind = "mixed-ambiguous-access";
@@ -79,6 +92,27 @@ declare class Meaning_mixedAmbiguousAccess {
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
+export declare class FirstStageResolutionResult {
+    readonly meaning: MeaningStage1;
+    readonly diagnostics: readonly Diagnostic[] | undefined;
+    constructor(meaning: MeaningStage1, diagnostics?: Diagnostic | readonly Diagnostic[]);
+}
+export type MeaningStage1 = Meaning_variableAccess | MeaningStage1_functionAccess | MeaningStage1_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+declare class MeaningStage1_typeAccessAtCalleePosition {
+    readonly types: readonly NamedTypeEntity[];
+    readonly kind = "type-access-at-callee-position";
+    constructor(types: readonly NamedTypeEntity[]);
+}
+declare class MeaningStage1_functionAccess {
+    readonly functions: readonly NotSubstitutedAccessedFunction[];
+    readonly kind = "function-access";
+    constructor(functions: readonly NotSubstitutedAccessedFunction[]);
+}
+declare class MeaningStage1_operatorAccess {
+    readonly operators: readonly types.Operator[];
+    readonly kind = "operator-access";
+    constructor(operators: readonly types.Operator[]);
+}
 export type AccessedVariable = AccessedVariable_entity | AccessedVariable_typeMember;
 export declare class AccessedVariable_entity implements IAccessedVariable {
     readonly value: VariableEntity;

package/build/types/analysis/IndexedAccessExpressionMeaning.d.ts

@@ -15,8 +15,8 @@ export declare class Resolver {
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: Diagnostic | undefined;
-    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined);
+    readonly diagnostics?: readonly Diagnostic[] | undefined;
+    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
 }
 export type Meaning = Meaning_resolved | Meaning_unresolved;
 declare class Meaning_resolved {
@@ -25,6 +25,7 @@ declare class Meaning_resolved {
     readonly accessKind: AccessKind;
     readonly kind = "resolved";
     get singleSuitableIndexer(): types.Indexer | undefined;
+    get singleIndexer(): types.Indexer | undefined;
     constructor(candidates: readonly types.Indexer[], suitableIndexers: readonly types.Indexer[], accessKind: AccessKind);
 }
 declare class Meaning_unresolved {