@artel/artc 0.6.25255 → 0.6.25256

package/build/{chunk-SSG7MY2R.js → chunk-IHZZGWNS.js}

@@ -10,7 +10,7 @@ import {
   WellKnownDeclarationsLoadError,
   __async,
   createTsInteropInputsForCompilation
-} from "./chunk-Y23FSWAN.js";
+} from "./chunk-ER3TEZSN.js";
 
 // source/executor/Compiler.ts
 var Compiler = class {

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

@@ -8,6 +8,8 @@ export type NotSubstitutedAccessedFunction = AccessedFunction_entity | AccessedF
 export declare class AccessedFunction_entity implements IAccessedFunction {
     readonly value: PackageOrNestedFunctionEntity;
     readonly kind = "entity";
+    private readonly _valueParameters;
+    private readonly _signatureType;
     get debuggerDisplay(): string;
     constructor(value: PackageOrNestedFunctionEntity);
     getTypeParameters(): readonly TypeParameterEntity[];
@@ -16,11 +18,13 @@ export declare class AccessedFunction_entity implements IAccessedFunction {
     getEntity(): PackageOrNestedFunctionEntity;
     getName(): Name;
     getSignatureType(analyzer: Analyzer): types.FunctionType;
-    applySubstitutions(analyzer: Analyzer, map: types.Substitutions): AccessedFunction;
+    applySubstitutions(substitutions: types.Substitutions): AccessedFunction;
+    getOuterSubstitutions(): types.Substitutions | undefined;
 }
 export declare class AccessedFunction_typeMember implements IAccessedFunction {
     readonly value: types.Method;
     readonly kind = "type-member";
+    private readonly _valueParameters;
     get debuggerDisplay(): string;
     constructor(value: types.Method);
     getTypeParameters(): readonly TypeParameterEntity[];
@@ -29,7 +33,8 @@ export declare class AccessedFunction_typeMember implements IAccessedFunction {
     getEntity(): MethodEntity;
     getName(): Name;
     getSignatureType(_analyzer: Analyzer): types.FunctionType;
-    applySubstitutions(_analyzer: Analyzer, substitutions: types.Substitutions): AccessedFunction;
+    applySubstitutions(substitutions: types.Substitutions): AccessedFunction;
+    getOuterSubstitutions(): types.Substitutions | undefined;
 }
 export declare class AccessedFunction_substitutedFunction implements IAccessedFunction {
     readonly value: SubstitutedFunction;
@@ -41,7 +46,8 @@ export declare class AccessedFunction_substitutedFunction implements IAccessedFu
     getReturnType(): types.Type;
     getEntity(): FunctionEntity;
     getName(): Name;
-    getSignatureType(_analyzer: Analyzer): types.FunctionType;
+    getSignatureType(analyzer: Analyzer): types.FunctionType;
+    getOuterSubstitutions(): types.Substitutions | undefined;
 }
 export declare class AccessedFunctionValueParameter {
     readonly entity: ParameterVariableEntity;
@@ -55,5 +61,6 @@ interface IAccessedFunction {
     getEntity(): FunctionEntity;
     getName(): Name;
     getSignatureType(analyzer: Analyzer): types.FunctionType;
+    getOuterSubstitutions(): types.Substitutions | undefined;
 }
 export {};

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

@@ -91,7 +91,6 @@ export declare class Analyzer {
     private readonly _prefixUnaryExpressionOperatorResolutionResults;
     private readonly _binaryExpressionUserDefinableOperatorResolutionResults;
     private readonly _assignmentStatementOperatorResolutionResults;
-    private readonly _functionEntitySignatureTypes;
     private readonly _valueParametersOfFunctionBlockLiterals;
     private readonly _extendedTypes;
     private readonly _analyzedTranslationPackages;
@@ -111,6 +110,7 @@ export declare class Analyzer {
     private readonly _localizedStandardTypes;
     private readonly _ownAndBaseConstructorCallsCheckResults;
     private readonly _expressionCanBeUsedInForLoopCheckResults;
+    private readonly _nameByIdentifierText;
     get tsInterop(): TsInteropContext;
     constructor(compilation: project.Compilation, tsInteropInputs: TsInteropInputs);
     getProjectSourceFile(node: tree.SourceFile): project.SourceFile;
@@ -130,21 +130,21 @@ export declare class Analyzer {
     checkBlockInvokesAsyncMethods(node: tree.StatementBlock | tree.FunctionBlock): boolean;
     getSyntacticAccessKind(node: tree.Expression): SyntacticAccessKind;
     getTypeMemberEntityContainer(node: tree.TypeMemberDeclaration): e.TypeMemberEntityContainer;
-    getTargetTypeOfExpression(node: tree.Expression, inferenceOptions?: InferenceOptions): types.Type | undefined;
+    getTargetTypeOfExpression(node: tree.Expression, analysisOptions?: ExpressionAnalysisOptions): types.Type | undefined;
     getUnambiguousTargetFunctionType(targetType: types.Type | undefined): types.FunctionType | undefined;
     getUnambiguousTargetArrayType(targetType: types.Type | undefined): types.Type | undefined;
     getEnumeratorElementType(node: tree.Node): types.Type | undefined;
     resolveMemberAccessExpressionFirstStage(node: tree.MemberAccessExpression): memberAccessExpressionResolution.FirstStageResolutionResult;
-    resolveMemberAccessExpression(node: tree.MemberAccessExpression, inferenceOptions?: InferenceOptions): memberAccessExpressionResolution.ResolutionResult;
+    resolveMemberAccessExpression(node: tree.MemberAccessExpression, analysisOptions?: ExpressionAnalysisOptions): memberAccessExpressionResolution.ResolutionResult;
     enumeratePackageImports(packageImportDirectives: Iterable<tree.PackageImportDirective>): Iterable<tree.PackageImport>;
     getSourceFileMembers(node: tree.SourceFile): ActualSourceFileMembers;
-    resolveCallExpression(node: tree.CallExpression, inferenceOptions?: InferenceOptions): callExpressionMeaning.ResolutionResult;
+    resolveCallExpression(node: tree.CallExpression, analysisOptions?: ExpressionAnalysisOptions): callExpressionMeaning.ResolutionResult;
     getRespectiveParameter(node: tree.Argument): MatchResultValueParameter | undefined;
     resolveIndexedAccessExpression(node: tree.IndexedAccessExpression): indexedAccessExpressionMeaning.ResolutionResult;
     getDereferenceExpressionMeaning(node: tree.DereferenceExpression): dereferenceExpressionMeaning.Meaning;
-    resolveAutotypeCallExpression(node: tree.AutotypeCallExpression, inferenceOptions?: InferenceOptions): autotypeCallExpressionMeaning.ResolutionResult;
+    resolveAutotypeCallExpression(node: tree.AutotypeCallExpression, analysisOptions?: ExpressionAnalysisOptions): autotypeCallExpressionMeaning.ResolutionResult;
     resolveIdentifierExpressionFirstStage(node: tree.IdentifierExpression): identifierExpressionResolution.FirstStageResolutionResult;
-    resolveIdentifierExpression(node: tree.IdentifierExpression, inferenceOptions?: InferenceOptions): identifierExpressionResolution.ResolutionResult;
+    resolveIdentifierExpression(node: tree.IdentifierExpression, analysisOptions?: ExpressionAnalysisOptions): identifierExpressionResolution.ResolutionResult;
     resolveTag(node: tree.Tag): tagMeaning.ResolutionResult;
     resolveObjectExpression(node: tree.ObjectExpression): objectExpressionMeaning.ResolutionResult;
     resolveBaseExpressionFirstStage(node: tree.BaseExpression): baseExpressionMeaning.FirstStageResolutionsResult;
@@ -262,7 +262,6 @@ export declare class Analyzer {
     excludeTypeFromUnion(initialType: types.Type, excludedType: types.Type): types.Type;
     isValueParameterVariadic(entity: e.VariableEntity): boolean;
     getDefaultTypeParameterConstraint(locale: PackageLocale): types.Type;
-    getSignatureTypeOfFunctionEntity(entity: e.FunctionEntity): types.FunctionType;
     getFunctionBlockLiteralValueParameters(node: tree.FunctionBlockLiteral): readonly e.ParameterVariableEntity[];
     getExtendedType(node: tree.TypeExtensionDeclaration): WithDiagnostics<e.NamedTypeEntity>;
     getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
@@ -317,8 +316,6 @@ export declare class Analyzer {
     determineUnderlyingTypeOfSourceVariantType(memberList: tree.TypeMemberDeclarationList): types.Type;
     getOwnAndBaseConstructorCallsCheckResult(node: TypeWithMembersDeclaration): OwnAndBaseConstructorCallsCheckResult;
     isConstructorCallingOwnConstructor(node: tree.ConstructorDeclaration): boolean;
-    createDiagnosticArgumentFactoryWithinPackage(entity: e.PackageEntity): DiagnosticArgumentFactory;
-    createDiagnosticArgumentFactoryWithinEntityContext(context: e.EntityContext): DiagnosticArgumentFactory;
     ifCalleeThenCallExpression(node: tree.Expression): tree.CallExpression | undefined;
     getNodeForAmbiguousAccessDiagnostic(access: tree.Expression): tree.Node;
     isPossibleWrappedTargetTypeDependentFunctionLiteral(node: tree.Expression): boolean;
@@ -362,13 +359,12 @@ declare class Type {
     private readonly _functionLiteralTypes;
     private readonly _nodesForWhichReturnTypeInferenceDiagnosticHasBeenReported;
     constructor(_analyzer: Analyzer);
-    ofExpression(node: tree.Expression, inferenceOptions?: InferenceOptions): types.Type;
+    ofExpression(node: tree.Expression, analysisOptions?: ExpressionAnalysisOptions): types.Type;
     ofTypeSpecifier(node: tree.TypeSpecifier): types.Type;
-    ofAccessedFunction(accessedFunction: AccessedFunction): types.Type;
     ofAccessedOperator(operator: types.Operator): types.Type;
-    ofRegularOrBlockFunctionLiteral(node: RegularOrBlockFunctionLiteral, inferenceOptions?: InferenceOptions): types.FunctionType;
-    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral, inferenceOptions?: InferenceOptions): types.FunctionType;
-    ofFunctionLiteral(node: tree.FunctionLiteral, inferenceOptions?: InferenceOptions): types.FunctionType;
+    ofRegularOrBlockFunctionLiteral(node: RegularOrBlockFunctionLiteral, analysisOptions?: ExpressionAnalysisOptions): types.FunctionType;
+    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral, analysisOptions?: ExpressionAnalysisOptions): types.FunctionType;
+    ofFunctionLiteral(node: tree.FunctionLiteral, analysisOptions?: ExpressionAnalysisOptions): types.FunctionType;
     private ofArrayLiteral;
     private ofAssertionExpression;
     private ofAssumptionExpression;
@@ -739,8 +735,8 @@ export declare class AnalyzedPackageImports {
 }
 export declare class PackageImportInfo {
     readonly entity: e.PackageEntity;
-    readonly isAliasedImport: e.PackageAliasEntity | undefined;
-    constructor(entity: e.PackageEntity, isAliasedImport: e.PackageAliasEntity | undefined);
+    readonly aliasEntity: e.PackageAliasEntity | undefined;
+    constructor(entity: e.PackageEntity, aliasEntity: e.PackageAliasEntity | undefined);
 }
 declare class TypeUtils {
     private readonly _analyzer;
@@ -855,15 +851,15 @@ export declare class DeclaredTypeMemberEntities {
     get namedMembers(): e.NamedTypeMemberEntity[];
     constructor(variables: readonly e.FieldEntity[], methods: readonly e.MethodEntity[], operators: readonly e.OperatorEntity[], constructors: readonly e.ConstructorEntity[], destructors: readonly e.DestructorEntity[], indexers: readonly e.SourceIndexerEntity[], dereferenceOperators: readonly e.DereferenceOperatorEntity[]);
 }
-export declare class InferenceOptions {
+export declare class ExpressionAnalysisOptions {
     readonly targetType: types.Type | undefined;
     readonly allowCaching: boolean;
-    readonly allowReportingDiagnostics: boolean;
-    constructor(targetType: types.Type | undefined, allowCaching: boolean, allowReportingDiagnostics: boolean);
-    static withTargetType(options: InferenceOptions | undefined, targetType: types.Type | undefined): InferenceOptions;
-    withTargetType(targetType: types.Type | undefined): InferenceOptions;
-    withAllowCaching(allowCaching: boolean): InferenceOptions;
-    withAllowReportingDiagnostics(allowReportingDiagnostics: boolean): InferenceOptions;
-    withTargetTypeAndAllowCaching(targetType: types.Type | undefined, allowCaching: boolean): InferenceOptions;
+    readonly isResolvingOverload: boolean;
+    constructor(targetType: types.Type | undefined, allowCaching: boolean, isResolvingOverload: boolean);
+    static withTargetType(options: ExpressionAnalysisOptions | undefined, targetType: types.Type | undefined): ExpressionAnalysisOptions;
+    withTargetType(targetType: types.Type | undefined): ExpressionAnalysisOptions;
+    withAllowCaching(allowCaching: boolean): ExpressionAnalysisOptions;
+    withIsResolvingOverload(isResolvingOverload: boolean): ExpressionAnalysisOptions;
+    withTargetTypeAndAllowCaching(targetType: types.Type | undefined, allowCaching: boolean): ExpressionAnalysisOptions;
 }
 export {};

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

@@ -1,12 +1,12 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { AutotypeCallExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
-import { Analyzer, InferenceOptions } from './index.js';
+import { Analyzer, ExpressionAnalysisOptions } from './index.js';
 export declare class Resolver {
     private readonly _analyzer;
-    readonly _node: AutotypeCallExpression;
-    readonly _inferenceOptions: InferenceOptions | undefined;
-    constructor(_analyzer: Analyzer, _node: AutotypeCallExpression, _inferenceOptions: InferenceOptions | undefined);
+    private readonly _node;
+    private readonly _analysisOptions;
+    constructor(_analyzer: Analyzer, _node: AutotypeCallExpression, _analysisOptions: ExpressionAnalysisOptions | undefined);
     resolve(): ResolutionResult;
 }
 export declare class ResolutionResult {

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

@@ -3,12 +3,12 @@ import { NamedTypeEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
-import { Analyzer, InferenceOptions } from './index.js';
+import { Analyzer, ExpressionAnalysisOptions } from './index.js';
 export declare class Resolver {
     private readonly _analyzer;
     private readonly _node;
-    private readonly _inferenceOptions;
-    constructor(_analyzer: Analyzer, _node: tree.CallExpression, _inferenceOptions: InferenceOptions | undefined);
+    private readonly _analysisOptions;
+    constructor(_analyzer: Analyzer, _node: tree.CallExpression, _analysisOptions: ExpressionAnalysisOptions | undefined);
     private get callee();
     resolve(): ResolutionResult;
     private checkExpressionDenotesType;

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

@@ -3,11 +3,11 @@ import { DiagnosticAcceptorWithArgumentFactory } from '../diagnostic/Diagnostic.
 import { IEntityHidingMatcher, NamedTypeEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
-import { Analyzer, InferenceOptions } from './Analyzer.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, inferenceOptions: InferenceOptions, locale: PackageLocale, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): ResolutionResult;
+    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 {

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/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

@@ -1,11 +1,11 @@
 import { DiagnosticAcceptorWithArgumentFactory } from '../diagnostic/Diagnostic.js';
 import * as tree from '../tree/index.js';
 import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
-import { Analyzer, InferenceOptions } from './Analyzer.js';
+import { Analyzer, ExpressionAnalysisOptions } from './Analyzer.js';
 export declare class Resolver {
-    static resolveByCallExpression(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], node: tree.CallExpression, inferenceOptions: InferenceOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined): ResolutionResult;
-    static resolveByCallExpressionParts(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], argumentList: tree.ArgumentList | undefined, typeArgumentClause: tree.TypeArgumentClause | undefined, inferenceOptions: InferenceOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): ResolutionResult;
-    static resolveByTargetType(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], typeArgumentClause: tree.TypeArgumentClause | undefined, inferenceOptions: InferenceOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): ResolutionResult;
+    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;
 }

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

@@ -6,7 +6,7 @@ import * as types from '../types/index.js';
 import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
 import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import { Analyzer, InferenceOptions } from './index.js';
+import { Analyzer, ExpressionAnalysisOptions } from './index.js';
 import { NamedDeclaration } from './semantic-context/index.js';
 export declare class FirstStageResolver {
     private readonly _semanticContext;
@@ -24,8 +24,8 @@ export declare class SecondStageResolver {
     private readonly _analyzer;
     private readonly _node;
     private readonly _firstStageResolutionResult;
-    private readonly _inferenceOptions;
-    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, firstStageResolutionResult: FirstStageResolutionResult, inferenceOptions: InferenceOptions | undefined);
+    private readonly _analysisOptions;
+    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, firstStageResolutionResult: FirstStageResolutionResult, analysisOptions: ExpressionAnalysisOptions | undefined);
     resolve(): ResolutionResult;
     private resolveTypeAccessAtCalleePosition;
     private resolveFunctionAccess;

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

@@ -6,7 +6,7 @@ import * as types from '../types/index.js';
 import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
 import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import { Analyzer, InferenceOptions } from './index.js';
+import { Analyzer, ExpressionAnalysisOptions } from './index.js';
 export declare class FirstStageResolver {
     private readonly _semanticContext;
     private readonly _analyzer;
@@ -29,8 +29,8 @@ export declare class SecondStageResolver {
     private readonly _analyzer;
     private readonly _node;
     private readonly _firstStageResolutionResult;
-    private readonly _inferenceOptions;
-    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, firstStageResolutionResult: FirstStageResolutionResult, inferenceOptions: InferenceOptions | undefined);
+    private readonly _analysisOptions;
+    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, firstStageResolutionResult: FirstStageResolutionResult, analysisOptions: ExpressionAnalysisOptions | undefined);
     resolve(): ResolutionResult;
     private resolveTypeAccessAtCalleePosition;
     private resolvePackageFunctionAccess;

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

@@ -1,4 +1,4 @@
-import { Analyzer, InferenceOptions } from '../analysis/index.js';
+import { Analyzer, ExpressionAnalysisOptions } from '../analysis/index.js';
 import { Displayable, Name } from '../common/index.js';
 import { DiagnosticAcceptorWithArgumentFactory, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
 import { TypeParameterEntity } from '../entities/index.js';
@@ -12,11 +12,11 @@ export declare class OverloadResolver<TSignature extends ISignature<TParameter>,
     private readonly _mode;
     private readonly _signatures;
     private readonly _arguments;
-    private readonly _inferenceOptions;
+    private readonly _analysisOptions;
     private readonly _dataForTypeArgumentInference;
     private readonly _diagnostics;
     private readonly _nodesForDiagnostic;
-    constructor(_analyzer: Analyzer, _mode: ResolutionMode, _signatures: readonly TSignature[], _arguments: readonly TArgument[], _inferenceOptions: InferenceOptions, _dataForTypeArgumentInference: DataForTypeArgumentInference | undefined, _diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, _nodesForDiagnostic: NodesForDiagnostic | undefined);
+    constructor(_analyzer: Analyzer, _mode: ResolutionMode, _signatures: readonly TSignature[], _arguments: readonly TArgument[], _analysisOptions: ExpressionAnalysisOptions, _dataForTypeArgumentInference: DataForTypeArgumentInference | undefined, _diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, _nodesForDiagnostic: NodesForDiagnostic | undefined);
     resolveOverload(): ProcessedSignature<TSignature, TParameter, TArgument>[];
     private areArgumentTypesAssignableToParameterTypes;
     private tryChooseBestSignature;
@@ -55,10 +55,10 @@ export declare class IntrinsicArgument implements matcher.IArgument, inferrer.In
     get name(): Name | undefined;
     constructor(type: types.Type);
     getDiagnosticLocation(): DiagnosticLocation | undefined;
-    getType(_inferenceOptions: InferenceOptions | undefined): types.Type;
+    getType(_analysisOptions: ExpressionAnalysisOptions | undefined): types.Type;
 }
 interface IArgument {
-    getType(inferenceOptions: InferenceOptions | undefined): types.Type;
+    getType(analysisOptions: ExpressionAnalysisOptions | undefined): types.Type;
 }
 export declare class SourceNodeArgument implements SourceArgument {
     readonly kind = "source";
@@ -68,7 +68,7 @@ export declare class SourceNodeArgument implements SourceArgument {
     get expression(): tree.Expression;
     constructor(analyzer: Analyzer, node: tree.Argument);
     getDiagnosticLocation(): DiagnosticLocation;
-    getType(inferenceOptions: InferenceOptions | undefined): types.Type;
+    getType(analysisOptions: ExpressionAnalysisOptions | undefined): types.Type;
 }
 export declare class SourceExpressionArgument implements SourceArgument {
     private readonly _analyzer;
@@ -77,7 +77,7 @@ export declare class SourceExpressionArgument implements SourceArgument {
     get name(): Name | undefined;
     constructor(_analyzer: Analyzer, expression: tree.Expression);
     getDiagnosticLocation(): DiagnosticLocation;
-    getType(inferenceOptions: InferenceOptions | undefined): types.Type;
+    getType(analysisOptions: ExpressionAnalysisOptions | undefined): types.Type;
 }
 export declare class DataForTypeArgumentInference {
     readonly specifiedTypeArguments: readonly types.Type[];

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

@@ -3,6 +3,8 @@ import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { PackageAliasEntity, PackageFunctionEntity, PackageTypeEntity, PackageVariableEntity, TypeExtensionEntity } from '../entities/index.js';
 import { Analyzer } from './Analyzer.js';
 export declare class SourceFileMembers {
+    private static readonly _emptyNamedMembers;
+    private static readonly _emptyPackageAliases;
     private readonly _analyzer;
     private readonly _namedMembers;
     private readonly _typeExtensions;

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

@@ -1,24 +1,24 @@
 import { Name } from '../common/index.js';
-import { FunctionEntity, PackageOrNestedFunctionEntity, ParameterVariableEntity } from '../entities/index.js';
+import { FunctionEntity, PackageOrNestedFunctionEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
+import { AccessedFunctionValueParameter } from './AccessedFunction.js';
+import { Analyzer } from './Analyzer.js';
 export type SubstitutedFunction = SubstitutedFunction_entity | SubstitutedFunction_typeMember;
 export declare class SubstitutedFunction_entity implements ISubstitutedFunction {
     readonly entity: PackageOrNestedFunctionEntity;
-    readonly entitySignatureType: types.FunctionType;
     readonly substitutions: types.Substitutions;
     readonly kind = "entity";
     private readonly _signatureType;
+    private readonly _valueParameters;
     get debuggerDisplay(): string;
-    constructor(entity: PackageOrNestedFunctionEntity, entitySignatureType: types.FunctionType, substitutions: types.Substitutions);
+    constructor(entity: PackageOrNestedFunctionEntity, substitutions: types.Substitutions);
     getEntity(): PackageOrNestedFunctionEntity;
     getName(): Name;
-    getSignatureType(): types.FunctionType;
+    getSignatureType(analyzer: Analyzer): types.FunctionType;
     getSubstitutions(): types.Substitutions;
-    getCombinedSubstitutions(): types.Substitutions;
-    getValueParameters(): readonly {
-        entity: ParameterVariableEntity;
-        type: types.Type;
-    }[];
+    getOuterSubstitutions(): types.Substitutions | undefined;
+    getValueParameters(): readonly AccessedFunctionValueParameter[];
+    getReturnType(): types.Type;
     isAsync(): boolean;
 }
 export declare class SubstitutedFunction_typeMember implements ISubstitutedFunction {
@@ -26,30 +26,26 @@ export declare class SubstitutedFunction_typeMember implements ISubstitutedFunct
     readonly substitutions: types.Substitutions;
     readonly kind = "type-member";
     private readonly _signatureType;
-    private readonly _combinedSubstitutions;
+    private readonly _valueParameters;
     get debuggerDisplay(): string;
     constructor(method: types.Method, substitutions: types.Substitutions);
     getEntity(): FunctionEntity;
     getName(): Name;
-    getSignatureType(): types.FunctionType;
+    getSignatureType(analyzer: Analyzer): types.FunctionType;
     getSubstitutions(): types.Substitutions;
-    getCombinedSubstitutions(): types.Substitutions;
-    getValueParameters(): readonly {
-        entity: ParameterVariableEntity;
-        type: types.Type;
-    }[];
+    getOuterSubstitutions(): types.Substitutions | undefined;
+    getValueParameters(): readonly AccessedFunctionValueParameter[];
+    getReturnType(): types.Type;
     isAsync(): boolean;
 }
 interface ISubstitutedFunction {
     getEntity(): FunctionEntity;
     getName(): Name;
-    getSignatureType(): types.FunctionType;
+    getSignatureType(analyzer: Analyzer): types.FunctionType;
     getSubstitutions(): types.Substitutions;
-    getCombinedSubstitutions(): types.Substitutions;
-    getValueParameters(): readonly {
-        entity: ParameterVariableEntity;
-        type: types.Type;
-    }[];
+    getOuterSubstitutions(): types.Substitutions | undefined;
+    getValueParameters(): readonly AccessedFunctionValueParameter[];
+    getReturnType(): types.Type;
     isAsync(): boolean;
 }
 export {};

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

@@ -1,7 +1,7 @@
 import { TypeParameterEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
-import { Analyzer, InferenceOptions } from './Analyzer.js';
+import { Analyzer, ExpressionAnalysisOptions } from './Analyzer.js';
 export type Argument = SourceArgument | IntrinsicArgument;
 export interface SourceArgument {
     readonly kind: 'source';
@@ -20,7 +20,7 @@ export declare class TypeArgumentInferrer {
     private readonly _analyzer;
     private readonly _typeParameters;
     private readonly _arguments;
-    private readonly _inferenceOptions;
+    private readonly _analysisOptions;
     private readonly _returnType;
     private readonly _outerSubstitutions;
     private readonly _inferenceStates;
@@ -29,7 +29,7 @@ export declare class TypeArgumentInferrer {
      */
     private readonly _unresolvedType;
     private _inferenceHasFailed;
-    constructor(analyzer: Analyzer, typeParameters: readonly TypeParameterEntity[], args: readonly ArgumentWithTargetParameterInfo[], inferenceOptions: InferenceOptions, returnType: types.Type | undefined, outerTypeSubstitutions: types.Substitutions | undefined);
+    constructor(analyzer: Analyzer, typeParameters: readonly TypeParameterEntity[], args: readonly ArgumentWithTargetParameterInfo[], analysisOptions: ExpressionAnalysisOptions, returnType: types.Type | undefined, outerTypeSubstitutions: types.Substitutions | undefined);
     infer(): readonly types.Type[] | undefined;
     private inferFirstStage;
     private inferSecondStage;

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

@@ -2,6 +2,6 @@ import { Node, SourceFile } from '../tree/index.js';
 type ChildNodeVisitor = (syntaxNode: VisitedChildNode) => void;
 export type VisitedNode = Node;
 export type VisitedChildNode = Exclude<Node, SourceFile>;
-export declare function visitChildren(node: VisitedNode, visitChildCb: ChildNodeVisitor): void;
-export declare function visitChildrenRecursively(node: VisitedNode, visitChildCb: ChildNodeVisitor): void;
+export declare function visitChildren(node: VisitedNode, visitTokens: boolean, visitChildCb: ChildNodeVisitor): void;
+export declare function visitChildrenRecursively(node: VisitedNode, visitTokens: boolean, visitChildCb: ChildNodeVisitor): void;
 export {};

package/build/types/analysis/semantic-context/SemanticContextBase.d.ts

@@ -10,6 +10,10 @@ import { FunctionDeclaration, GetterDeclaration, RegularOrBlockFunctionLiteral,
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';
 export declare abstract class SemanticContextBase {
+    protected static readonly _emptyTypesOrContainersWithTypes: readonly TypeOrContainerWithTypes[];
+    protected static readonly _emptyNamedDeclarations: readonly NamedDeclaration[];
+    protected static readonly _emptyOperators: readonly types.Operator[];
+    protected static readonly _emptyTypeExtensions: readonly TypeExtensionEntity[];
     abstract readonly outer: SemanticContext | undefined;
     protected abstract readonly asContext: SemanticContext;
     abstract getContainingSubprogram(): SubprogramInfo | undefined;

package/build/types/common/ArrayUtils.d.ts

@@ -8,6 +8,8 @@ export declare class ArrayUtils {
     static pushElementIfUniqueComparingWithEquals<T extends WithEqualsMethod<T>>(array: T[] | undefined, element: T): boolean;
     static pushElementsIfUniqueComparingWithEquals<T extends WithEqualsMethod<T>>(array: T[] | undefined, elements: readonly T[]): void;
     static count<T>(array: readonly T[], cb: (v: T) => boolean): number;
+    static compareWithEqualsIgnoringOrder<T extends WithEqualsMethod<T>>(array1: readonly T[], array2: readonly T[]): boolean;
+    static compareWithComparatorIgnoringOrder<T1, T2>(array1: readonly T1[], array2: readonly T2[], comparator: (e1: T1, e2: T2) => boolean): boolean;
 }
 export type WithEqualsMethod<T> = {
     equals(t: T): boolean;

package/build/types/common/Cached.d.ts

@@ -8,3 +8,5 @@ export declare class Cached<T> {
     clear(): void;
     getCachedValue(): T | undefined;
 }
+export declare class RecursiveCachedValueEvaluationError extends Error {
+}

package/build/types/common/Lazy.d.ts

@@ -7,6 +7,8 @@ export declare class Lazy<T> {
     get value(): T;
     getCachedValue(): T | undefined;
 }
+export declare class RecursiveLazyValueEvaluationError extends Error {
+}
 export type MaybeLazy<T> = Lazy<T> | T;
 export declare namespace MaybeLazy {
     function getValue<T>(maybeLazy: MaybeLazy<T>): T;