@artel/artc 0.6.25225 → 0.6.25227

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

@@ -0,0 +1,9 @@
+import { SemanticContext } from './SemanticContext.js';
+import { SemanticContextBase, SubprogramInfo, TryStatementContextKind, TypeOrTypeExtension } from './SemanticContextBase.js';
+export declare abstract class SemanticContextWithParent extends SemanticContextBase {
+    abstract readonly outer: SemanticContext;
+    getContainingSubprogram(): SubprogramInfo | undefined;
+    getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+    getTryStatementContext(): TryStatementContextKind | undefined;
+    isStatic(): boolean;
+}

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

@@ -0,0 +1,42 @@
+import { SearchName } from '../../common/index.js';
+import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
+import { PackageEntity, TypeEntity, TypeExtensionEntity } from '../../entities/index.js';
+import { SourceFile } from '../../project/SourceFile.js';
+import * as tree from '../../tree/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { FoundNamedDeclaration } from '../FoundDeclaration.js';
+import { LocalizationContext } from '../LocalizationContext.js';
+import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
+import { SemanticContext } from './SemanticContext.js';
+import { SemanticContextBase, SubprogramInfo, TryStatementContextKind, TypeOrTypeExtension } from './SemanticContextBase.js';
+export declare class SourceFileSemanticContext extends SemanticContextBase {
+    readonly kind = "source-file";
+    readonly outer: SemanticContext | undefined;
+    protected asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _sourceFile;
+    private readonly _sourceFileMembers;
+    private readonly _containingPackageMemberLookup;
+    private readonly _importedPackageMemberLookups;
+    private readonly _packageNameSegments;
+    private readonly _packageNameSegmentsByKey;
+    private readonly _locale;
+    private get packageNameSegmentsByKey();
+    constructor(analyzer: Analyzer, node: tree.SourceFile);
+    getContainingSubprogram(): SubprogramInfo | undefined;
+    getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+    getSourceFile(): SourceFile;
+    getPackage(): PackageEntity;
+    getTryStatementContext(): TryStatementContextKind | undefined;
+    getLocalizationContext(): LocalizationContext;
+    isStatic(): boolean;
+    getOwnTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnNamedDeclarations(_noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnNamedDeclarationsByName(name: SearchName, _noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnTypeExtensionsByType(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
+    private convertPackageMemberToNamedDeclaration;
+    private convertPackageAliasToTypeOrContainerWithTypes;
+    private convertPackageMemberToTypeOrContainerWithTypes;
+    private convertPackageAliasToNamedDeclaration;
+}

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

@@ -0,0 +1,23 @@
+import { LocalVariableEntity } from '../../entities/VariableEntity.js';
+import * as tree from '../../tree/index.js';
+import { Analyzer } from '../Analyzer.js';
+type SpecialLocalDeclarationEntity = LocalVariableEntity;
+export declare class SpecialLocalDeclarationsBuilder {
+    static buildForFunctionBlock(analyzer: Analyzer, node: tree.FunctionBlock): readonly SpecialLocalDeclarationEntity[];
+    static buildForFunctionBlockLiteral(analyzer: Analyzer, node: tree.FunctionBlockLiteral): readonly SpecialLocalDeclarationEntity[];
+    static buildForPackageFunctionDeclaration(analyzer: Analyzer, node: tree.PackageFunctionDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForFieldGetterDeclaration(analyzer: Analyzer, node: tree.FieldGetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForFieldSetterDeclaration(analyzer: Analyzer, node: tree.FieldSetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForPackageVariableGetterDeclaration(analyzer: Analyzer, node: tree.PackageVariableGetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForPackageVariableSetterDeclaration(analyzer: Analyzer, node: tree.PackageVariableSetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForIndexedElementGetterDeclaration(analyzer: Analyzer, node: tree.IndexedElementGetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForIndexedElementSetterDeclaration(analyzer: Analyzer, node: tree.IndexedElementSetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForDereferencedVariableGetterDeclaration(analyzer: Analyzer, node: tree.DereferencedVariableGetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForDereferencedVariableSetterDeclaration(analyzer: Analyzer, node: tree.DereferencedVariableSetterDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForNestedFunctionDeclaration(analyzer: Analyzer, node: tree.NestedFunctionDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForFunctionLiteral(analyzer: Analyzer, node: tree.FunctionLiteral): readonly SpecialLocalDeclarationEntity[];
+    static buildForConstructorDeclaration(analyzer: Analyzer, node: tree.ConstructorDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForMethodDeclaration(analyzer: Analyzer, node: tree.MethodDeclaration): readonly SpecialLocalDeclarationEntity[];
+    static buildForOperatorDeclaration(analyzer: Analyzer, node: tree.OperatorDeclaration): readonly SpecialLocalDeclarationEntity[];
+}
+export {};

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

@@ -0,0 +1,122 @@
+import { SearchName } from '../../common/index.js';
+import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
+import * as tree from '../../tree/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { FoundNamedDeclaration } from '../FoundDeclaration.js';
+import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, RegularOrBlockFunctionLiteral } from '../NodeTypeUtils.js';
+import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
+import { SemanticContext } from './SemanticContext.js';
+import { SubprogramInfo, TryStatementContextKind } from './SemanticContextBase.js';
+import { MemberOfSemanticContextValidatingNameConflicts, MemberOfSemanticContextValidatingNameConflictsForTypeLookup, SubprogramParameterSemanticContext, SubprogramParameterSemanticContextParent } from './SemanticContextValidatingNameConflicts.js';
+import { SemanticContextWithParent } from './SemanticContextWithParent.js';
+import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
+import { SemanticContextContainingTypeMember } from './TypeSemanticContext.js';
+export type LastSemanticContextOfSubprogramParent = SemanticContext;
+/**
+ * Завершающий семантический контекст подпрограммы.
+ * Данный контекст располагается после контекста с параметрами (или параметрами типа) и переопределяет метод
+ * {@link ISemanticContext.getContainingSubprogram}.
+ */
+export declare abstract class OutermostSemanticContextOfSubprogram extends SemanticContextWithParent {
+    readonly kind = "outermost-of-subprogram";
+    abstract getContainingSubprogram(): SubprogramInfo;
+    getTryStatementContext(): TryStatementContextKind | undefined;
+    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnTypesOrContainersWithTypesByName(_name: SearchName, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnNamedDeclarationsByName(_name: SearchName, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+}
+export declare class FunctionSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SemanticContext;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: FunctionDeclaration, outer: SemanticContext);
+    getContainingSubprogram(): SubprogramInfo;
+    isStatic(): boolean;
+}
+export declare class FunctionBlockLiteralParameterSemanticContext extends SubprogramParameterSemanticContext {
+    readonly node: tree.FunctionBlockLiteral;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.FunctionBlockLiteral, outer: SubprogramParameterSemanticContextParent);
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export declare class PackageConstructorSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SourceFileSemanticContext;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.PackageConstructorDeclaration, outer: SourceFileSemanticContext);
+    getContainingSubprogram(): SubprogramInfo;
+}
+export declare class PackageEntryPointSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SourceFileSemanticContext;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.PackageEntryPointDeclaration, outer: SourceFileSemanticContext);
+    getContainingSubprogram(): SubprogramInfo;
+}
+export declare class OperatorSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SemanticContextContainingTypeMember;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.OperatorDeclaration, outer: SemanticContextContainingTypeMember);
+    getContainingSubprogram(): SubprogramInfo;
+    isStatic(): boolean;
+}
+export declare class ConstructorSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SemanticContextContainingTypeMember;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.ConstructorDeclaration, outer: SemanticContextContainingTypeMember);
+    getContainingSubprogram(): SubprogramInfo;
+}
+export declare class DestructorSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SemanticContextContainingTypeMember;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: tree.DestructorDeclaration, outer: SemanticContextContainingTypeMember);
+    getContainingSubprogram(): SubprogramInfo;
+}
+export type AccessorSemanticContextParent = SemanticContextContainingTypeMember | SourceFileSemanticContext;
+export type VariableAccessorDeclaration = PackageVariableAccessorDeclaration | FieldAccessorDeclaration | DereferencedVariableAccessorDeclaration;
+export declare class VariableAccessorSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: AccessorSemanticContextParent;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: VariableAccessorDeclaration, outer: AccessorSemanticContextParent);
+    getContainingSubprogram(): SubprogramInfo;
+    isStatic(): boolean;
+}
+export declare class IndexedElementAccessorSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: AccessorSemanticContextParent;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: IndexedElementAccessorDeclaration, outer: AccessorSemanticContextParent);
+    getContainingSubprogram(): SubprogramInfo;
+    isStatic(): boolean;
+}
+export declare class FunctionLiteralSemanticContext extends OutermostSemanticContextOfSubprogram {
+    readonly outer: SemanticContext;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _subprogramInfo;
+    constructor(analyzer: Analyzer, node: RegularOrBlockFunctionLiteral, outer: SemanticContext);
+    getContainingSubprogram(): SubprogramInfo;
+}

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

@@ -0,0 +1,109 @@
+import { SearchName } from '../../common/index.js';
+import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
+import { OperatorKind } from '../../entities/index.js';
+import * as tree from '../../tree/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { FoundAnonymousDeclaration, FoundNamedDeclaration } from '../FoundDeclaration.js';
+import { FunctionTypeDeclaration, StructuredTypeDeclaration, VariantTypeDeclaration } from '../NodeTypeUtils.js';
+import { TypeMemberLookup } from '../TypeMemberLookup.js';
+import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
+import { SemanticContext } from './SemanticContext.js';
+import { SubprogramInfo, TypeOrTypeExtension } from './SemanticContextBase.js';
+import { SemanticContextWithParent } from './SemanticContextWithParent.js';
+import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
+export type TypeDeclarationCreatingSemanticContext = StructuredTypeDeclaration | VariantTypeDeclaration | FunctionTypeDeclaration | tree.PackageAliasTypeDeclaration;
+/**
+ * Завершающий семантический контекст типа.
+ * Поскольку контекст с параметрами типа является опциональным, необходим
+ * ещё один контекст, который гарантированно переопределит метод `getContainingTypeOrTypeExtension`.
+ */
+export declare class OutermostSemanticContextOfType extends SemanticContextWithParent {
+    readonly kind = "outermost-of-type";
+    readonly outer: SemanticContext;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    constructor(analyzer: Analyzer, node: TypeDeclarationCreatingSemanticContext, outer: SemanticContext);
+    getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+    getContainingSubprogram(): SubprogramInfo | undefined;
+    isStatic(): boolean;
+    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnTypesOrContainersWithTypesByName(_name: SearchName, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnNamedDeclarationsByName(_name: SearchName, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    private getContainingType;
+}
+type TypeDeclarationWithTypeParameters = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.PackageFunctionTypeDeclaration;
+export declare class TypeParametersOfTypeSemanticContext extends SemanticContextWithParent {
+    readonly kind = "type-parameter-of-type";
+    readonly outer: OutermostSemanticContextOfType;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _typeParameterClause;
+    private readonly _typesOrContainerWithTypes;
+    private readonly _typesOrContainerWithTypesByName;
+    private get typesOrContainerWithTypes();
+    private get typesOrContainerWithTypesByName();
+    constructor(analyzer: Analyzer, node: TypeDeclarationWithTypeParameters, typeParameterClause: tree.TypeParameterClause, outer: OutermostSemanticContextOfType);
+    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnTypesOrContainersWithTypesByName(name: SearchName, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnNamedDeclarationsByName(_name: SearchName, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    private createTypesOrContainerWithTypes;
+}
+declare abstract class TypeOrExtensionBodySemanticContext extends SemanticContextWithParent {
+    protected abstract memberLookup: TypeMemberLookup;
+    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnTypesOrContainersWithTypesByName(_name: SearchName, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnNamedDeclarations(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnNamedDeclarationsByName(name: SearchName, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnOperators(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getOwnOperatorsByKind(kind: OperatorKind, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
+    private convertNamedMember;
+}
+export type TypeDeclarationWithMembersBody = tree.StructuredTypeDeclarationBody | tree.VariantTypeDeclarationBody | tree.AliasTypeDeclarationBody;
+export type SemanticContextContainingTypeMember = TypeBodySemanticContext | TypeExtensionBodySemanticContext;
+export type TypeBodySemanticContextParent = TypeParametersOfTypeSemanticContext | OutermostSemanticContextOfType;
+export declare class TypeBodySemanticContext extends TypeOrExtensionBodySemanticContext {
+    readonly kind = "type-body";
+    readonly outer: TypeBodySemanticContextParent;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _memberLookup;
+    protected get memberLookup(): TypeMemberLookup;
+    constructor(analyzer: Analyzer, node: TypeDeclarationWithMembersBody, outer: TypeBodySemanticContextParent);
+    private getTypeEntity;
+}
+export declare class TypeExtensionBodySemanticContext extends TypeOrExtensionBodySemanticContext {
+    readonly kind = "type-extension-body";
+    readonly outer: SourceFileSemanticContext;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _memberLookup;
+    protected get memberLookup(): TypeMemberLookup;
+    constructor(analyzer: Analyzer, node: tree.TypeExtensionDeclaration, outer: SourceFileSemanticContext);
+    getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
+}
+export type ParameterOfFunctionTypeSemanticContextParent = TypeParametersOfTypeSemanticContext | OutermostSemanticContextOfType;
+export declare class ParametersOfFunctionTypeSemanticContext extends SemanticContextWithParent {
+    readonly kind = "parameters-of-function-type";
+    readonly outer: ParameterOfFunctionTypeSemanticContextParent;
+    protected readonly asContext: SemanticContext;
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _namedDeclarations;
+    private readonly _namedDeclarationsByName;
+    private get namedDeclarations();
+    private get namedDeclarationsByName();
+    constructor(analyzer: Analyzer, node: tree.FunctionTypeDeclarationBody, outer: ParameterOfFunctionTypeSemanticContextParent);
+    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnTypesOrContainersWithTypesByName(name: SearchName, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getOwnNamedDeclarationsByName(name: SearchName, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    private createNamedDeclarations;
+}
+export {};

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

@@ -0,0 +1,9 @@
+export * from './Declarations.js';
+export * from './FieldWithInitializerSemanticContext.js';
+export * from './SemanticContext.js';
+export * from './SemanticContextBase.js';
+export * from './SemanticContextBuilder.js';
+export * from './SemanticContextValidatingNameConflicts.js';
+export * from './SourceFileSemanticContext.js';
+export * from './SubprogramSemanticContext.js';
+export * from './TypeSemanticContext.js';

package/build/types/api/Api.d.ts

@@ -1,9 +1,9 @@
 export * from '../analysis/AccessedFunction.js';
 export * from '../analysis/AnalyzedTranslationPackage.js';
 export * from '../analysis/Analyzer.js';
+export { MatchResult, MatchResultValueParameter } from '../analysis/ArgumentToParameterMatchResult.js';
 export type { Meaning as AutotypeCallExpressionMeaning } from '../analysis/AutotypeCallExpressionMeaning.js';
 export type { Meaning as BaseExpressionMeaning } from '../analysis/BaseExpressionMeaning.js';
-export { MatchResult, MatchResultValueParameter } from '../analysis/ArgumentToParameterMatchResult.js';
 export type { Meaning as CallExpressionMeaning } from '../analysis/CallExpressionMeaning.js';
 export type { Meaning as DereferenceExpressionMeaning } from '../analysis/DereferenceExpressionMeaning.js';
 export * from '../analysis/DiagnosticCollector.js';
@@ -15,13 +15,11 @@ export * from '../analysis/ImportedPackageNameTree.js';
 export type { Meaning as IndexedAccessExpressionMeaning } from '../analysis/IndexedAccessExpressionMeaning.js';
 export * from '../analysis/Localization.js';
 export * from '../analysis/LocalizationContext.js';
-export * from '../analysis/Lookup.js';
+export type { Meaning as MemberAccessExpressionMeaning, ResolutionResult as MemberAccessExpressionResolutionResult } from '../analysis/MemberAccessExpressionMeaning.js';
 export * from '../analysis/NodeTypeUtils.js';
 export type { Meaning as ObjectExpressionMeaning } from '../analysis/ObjectExpressionMeaning.js';
 export * from '../analysis/PackageMemberLookup.js';
-export type { Meaning as MemberAccessExpressionMeaning, ResolutionResult as MemberAccessExpressionResolutionResult } from '../analysis/MemberAccessExpressionMeaning.js';
-export type { IScope, NamedDeclaration, TypeOrContainerWithTypes } from '../analysis/Scope.js';
-export * from '../analysis/SemanticContext.js';
+export * as semanticContext from '../analysis/semantic-context/index.js';
 export * from '../analysis/SourceFileMembers.js';
 export * from '../analysis/SourcePackageDependencyGraph.js';
 export * from '../analysis/SubstitutedFunction.js';

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

@@ -0,0 +1,2 @@
+export declare class RecursiveAnalysisError extends Error {
+}

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

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

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

@@ -1,3 +1,4 @@
+import { MaybeLazy } from './Lazy.js';
 export declare abstract class Query<T> implements Iterable<T> {
     static from<T>(source: Iterable<T>): Query<T>;
     static fromNullable<T>(source: Iterable<T> | undefined): Query<T>;
@@ -15,7 +16,7 @@ export declare abstract class Query<T> implements Iterable<T> {
     flatMap<K>(fn: (t: T) => Iterable<K>): Query<K>;
     toArray(): T[];
     count(fn?: (t: T) => boolean): number;
-    chain(other: Iterable<T>): Query<T>;
+    chain(other: MaybeLazy<Iterable<T>>): Query<T>;
     filter<K extends T>(fn: (t: T) => t is K): Query<K>;
     filter(fn: (t: T) => boolean): Query<T>;
     mapAndFilter<K>(fn: (t: T) => K | undefined): Query<K>;

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

@@ -1,4 +1,5 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { MaybeLazy } from './Lazy.js';
 export type WithDiagnostics<T> = WithDiagnostics_ok<T> | WithDiagnostics_error<T>;
 export declare class WithDiagnostics_ok<T> implements IWithDiagnostics<T> {
     readonly value: T;
@@ -8,9 +9,9 @@ export declare class WithDiagnostics_ok<T> implements IWithDiagnostics<T> {
 }
 export declare class WithDiagnostics_error<T> implements IWithDiagnostics<T> {
     readonly kind = "error";
-    readonly value: readonly Diagnostic[];
-    constructor(diagnostic: Diagnostic);
-    constructor(diagnostics: readonly Diagnostic[]);
+    readonly value: readonly MaybeLazy<Diagnostic>[];
+    constructor(diagnostic: MaybeLazy<Diagnostic>);
+    constructor(diagnostics: readonly MaybeLazy<Diagnostic>[]);
     toNullable(): T | undefined;
 }
 interface IWithDiagnostics<T> {

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

@@ -5,6 +5,7 @@ export * from './CancellationToken.js';
 export * from './Constants.js';
 export * from './Debug.js';
 export * from './Delayed.js';
+export * from './Errors.js';
 export * from './FormatString.js';
 export * from './Interner.js';
 export * from './JavaScriptIdentifier.js';

package/build/types/diagnostic/DiagnosticCode.d.ts

@@ -1,9 +1,9 @@
 export declare enum DiagnosticCode {
-    UnterminatedToken = 1000,
-    UnterminatedMultiLineComment = 1001,
-    UnterminatedNumber = 1002,
-    UnterminatedTextOrTextTemplate = 1003,
-    UnterminatedQuotedIdentifier = 1004,
+    UnterminatedToken = 0,
+    UnterminatedMultiLineComment = 1,
+    UnterminatedNumber = 2,
+    UnterminatedTextOrTextTemplate = 3,
+    UnterminatedQuotedIdentifier = 4,
     IdentifierExpected = 101,
     TypeNameExpected = 102,
     PackageNameExpected = 103,
@@ -35,98 +35,104 @@ export declare enum DiagnosticCode {
     TagNameExpected = 129,
     TypeMemberTranslationExpected = 130,
     TranslationExpected = 131,
-    TypeCannotBeUsedAsValue = 2001,
-    PackageNameCannotBeUsedAsValue = 2002,
-    PackageAliasCannotBeUsedAsValue = 2003,
-    PackageMemberOrPackageNotFound = 2004,
-    PackageMemberNotFound = 2005,
-    TypeMemberNotFound = 2006,
-    ConstructorNotFound = 2007,
-    IndexerOfTheSpecifiedTypeNotFound = 2008,
-    DereferenceOperatorOfTheSpecifiedTypeNotFound = 2009,
-    IndexerNotFound = 2010,
-    CannotAccessStaticMembersOnTypeParameter = 2011,
-    CannotCreateInstanceOfAspect = 2012,
-    CannotCreateInstanceOfTypeParameter = 2013,
-    CannotCreateInstanceOfUnresolvedType = 2014,
-    ExpressionIsNotCallable = 2015,
-    ParameterForPositionalArgumentNotFound = 2016,
-    ParameterWithGivenNameNotFound = 2017,
-    NamedArgumentExpectedButPositionalArgumentFound = 2018,
-    ArgumentForParameterAlreadyAssigned = 2019,
-    NotAllRequiredParametersAreProvidedWithArguments = 2020,
-    UnknownVariable = 2021,
-    UnknownType = 2022,
-    TypeWithArity0NotFound = 2023,
-    VariableUsedBeforeBeingDeclared = 2024,
-    Type0IsNotAssignableToType1 = 2025,
-    VariableNotFound = 2026,
-    FunctionNotFound = 2027,
-    UnknownPackage = 2028,
-    CannotAssignValueToExpression = 2029,
-    CannotDetermineTargetTypeToCallTheConstructor = 2030,
-    AmbiguousAccess = 2031,
-    AmbiguousAccess0 = 2032,
-    CanNotAssignValueToContextVariable = 2033,
-    ExpectedPackageNameOrAliasButFoundType = 2034,
-    TypeExpected = 2035,
-    NameOfTypeOrPackageNotFound = 2036,
-    TypeIsNotATag = 2037,
-    ExpressionOfType0CanNotBeUsedForEnumeration = 2038,
-    Operator0IsNotDefinedForTypes1And2 = 2039,
-    Operator0IsNotDefinedForType1 = 2040,
-    VariantMustHaveAssociatedValue = 2041,
-    TranslationsCanOnlyBeDeclaredInTranslationPackage = 2042,
-    UnknownTranslatedPackage0 = 2043,
-    BaseCannotBeUsedInThisContext = 2044,
-    OverriddenMethodNotFound = 2045,
-    ObjectCannotBeUsedInThisContext = 2046,
-    BaseCannotBeUsedAsAnExpressionInItself = 2047,
-    InterfacePackageMustNotContainImplementation = 2048,
-    InterfacePackageVariablesMustNotHaveInitializers = 2049,
-    BodyIsMissing = 2050,
-    AbstractTypeMembersMustNotHaveBody = 2051,
-    AbstractVariablesMustNotHaveInitializers = 2052,
-    PackageIsAlreadyImportedInAnotherLanguage = 2053,
-    OnlySubprogramsWithReturnTypeCanReturnValue = 2054,
-    FunctionsUsingYieldStatementCanNotReturnValue = 2055,
-    YieldStatementCanNotBeUsedInAnonymousFunctions = 2056,
-    YieldStatementCanNotBeUsedHere = 2057,
-    FunctionsUsingYieldStatementMustHaveEnumerableAsReturnType = 2058,
-    YieldStatementCanNotBeUsedInTryStatementThatHasCatchClause = 2059,
-    YieldStatementCanNotBeUsedInFinallyClause = 2060,
-    SubprogramMustReturnValue = 2061,
-    ResultVariableCanNotBeUsedInFunctionsUsingYieldStatement = 2062,
-    TypeAliasReferencesItself = 2063,
-    TypeParameterHasCircularConstraint = 2064,
-    BaseTypeCausesInheritanceCycle = 2065,
-    OnlyGenericTypesAndFunctionsCanBeSpecialized = 2066,
-    Expected0TypeArguments = 2067,
-    ExpectedFrom0To1TypeArguments = 2068,
-    Type0IsNotAssignableToConstraint1 = 2069,
-    VariableIsDeclaredButNotUsed = 2070,
-    DefaultConstructorArgumentsMustBeNamed = 2071,
-    IncorrectBodyOfRedefinableAliasTypeMethod = 2072,
-    TheFollowingDeclarationsAreNotTranslated0 = 2073,
-    TheFollowingDeclarationAreNotTranslated0And1More = 2074,
-    OperatorFunctionMustNotBeStatic = 2075,
-    OperatorFunction0MustNotHaveParameters = 2076,
-    OperatorFunction0MustHaveOneParameter = 2077,
-    OperatorFunction0MustHaveNoMoreThanOneParameter = 2078,
-    CorrespondingRedefinableTypeMemberNotFound = 2079,
-    ConstructorCanNotBeRedefinable = 2080,
-    ConstructorCanNotBeRedefined = 2081,
-    AsyncFunctionCanOnlyBeCalledFromFunctionMarkedWithAsyncModifier = 2082,
-    TagNotFound = 2083,
-    TypeOrFunctionNameExpected = 2084,
-    PackageNameOrAliasExpected = 2085,
-    ExpressionCanBeNone = 2086,
-    NoneAwareAccessCanNotBeUsedOnTheLeftHandSideOfAssignmentStatement = 2087,
-    UnreachableCode = 2088,
-    CanNotFindTsLibDirectoryBaseSearchPaths0 = 2089,
-    SourceFile0IsNotPartOfThePackageAndWontBeLoaded = 2090,
-    ProgramWithoutMainPackageCanNotBeCompiled = 2091,
-    JsonConfigurationValidationError = 2092,
-    StandardPackage0NotFound = 2093,
-    Declaration0NotFoundInStandardPackage1 = 2094
+    TypeCannotBeUsedAsValue = 201,
+    PackageNameCannotBeUsedAsValue = 202,
+    PackageAliasCannotBeUsedAsValue = 203,
+    PackageMemberOrPackageNotFound = 204,
+    PackageMemberNotFound = 205,
+    TypeMemberNotFound = 206,
+    ConstructorNotFound = 207,
+    IndexerOfTheSpecifiedTypeNotFound = 208,
+    DereferenceOperatorOfTheSpecifiedTypeNotFound = 209,
+    IndexerNotFound = 210,
+    CannotAccessStaticMembersOnTypeParameter = 211,
+    CannotCreateInstanceOfAspect = 212,
+    CannotCreateInstanceOfTypeParameter = 213,
+    CannotCreateInstanceOfUnresolvedType = 214,
+    ExpressionIsNotCallable = 215,
+    ParameterForPositionalArgumentNotFound = 216,
+    ParameterWithGivenNameNotFound = 217,
+    NamedArgumentExpectedButPositionalArgumentFound = 218,
+    ArgumentForParameterAlreadyAssigned = 219,
+    NotAllRequiredParametersAreProvidedWithArguments = 220,
+    UnknownVariable = 221,
+    UnknownType = 222,
+    TypeWithArity0NotFound = 223,
+    VariableUsedBeforeBeingDeclared = 224,
+    Type0IsNotAssignableToType1 = 225,
+    VariableNotFound = 226,
+    FunctionNotFound = 227,
+    UnknownPackage = 228,
+    CannotAssignValueToExpression = 229,
+    CannotDetermineTargetTypeToCallTheConstructor = 230,
+    AmbiguousAccess = 231,
+    AmbiguousAccess0 = 232,
+    CannotAssignValueToContextVariable = 233,
+    ExpectedPackageNameOrAliasButFoundType = 234,
+    TypeExpected = 235,
+    NameOfTypeOrPackageNotFound = 236,
+    TypeIsNotATag = 237,
+    ExpressionOfType0CannotBeUsedForEnumeration = 238,
+    Operator0IsNotDefinedForTypes1And2 = 239,
+    Operator0IsNotDefinedForType1 = 240,
+    VariantMustHaveAssociatedValue = 241,
+    TranslationsCanOnlyBeDeclaredInTranslationPackage = 242,
+    UnknownTranslatedPackage0 = 243,
+    BaseCannotBeUsedInThisContext = 244,
+    OverriddenMethodNotFound = 245,
+    ObjectCannotBeUsedInThisContext = 246,
+    BaseCannotBeUsedAsAnExpressionInItself = 247,
+    InterfacePackageMustNotContainImplementation = 248,
+    InterfacePackageVariablesMustNotHaveInitializers = 249,
+    BodyIsMissing = 250,
+    AbstractTypeMembersMustNotHaveBody = 251,
+    AbstractVariablesMustNotHaveInitializers = 252,
+    PackageIsAlreadyImportedInAnotherLanguage = 253,
+    OnlySubprogramsWithReturnTypeCanReturnValue = 254,
+    FunctionsUsingYieldStatementCannotReturnValue = 255,
+    YieldStatementCannotBeUsedInAnonymousFunctions = 256,
+    YieldStatementCannotBeUsedHere = 257,
+    FunctionsUsingYieldStatementMustHaveEnumerableAsReturnType = 258,
+    YieldStatementCannotBeUsedInTryStatementThatHasCatchClause = 259,
+    YieldStatementCannotBeUsedInFinallyClause = 260,
+    SubprogramMustReturnValue = 261,
+    ResultVariableCannotBeUsedInFunctionsUsingYieldStatement = 262,
+    TypeAliasReferencesItself = 263,
+    TypeParameterHasCircularConstraint = 264,
+    BaseTypeCausesInheritanceCycle = 265,
+    OnlyGenericTypesAndFunctionsCanBeSpecialized = 266,
+    Expected0TypeArguments = 267,
+    ExpectedFrom0To1TypeArguments = 268,
+    Type0IsNotAssignableToConstraint1 = 269,
+    VariableIsDeclaredButNotUsed = 270,
+    DefaultConstructorArgumentsMustBeNamed = 271,
+    IncorrectBodyOfRedefinableAliasTypeMethod = 272,
+    TheFollowingDeclarationsAreNotTranslated0 = 273,
+    TheFollowingDeclarationAreNotTranslated0And1More = 274,
+    OperatorFunctionMustNotBeStatic = 275,
+    OperatorFunction0MustNotHaveParameters = 276,
+    OperatorFunction0MustHaveOneParameter = 277,
+    OperatorFunction0MustHaveNoMoreThanOneParameter = 278,
+    CorrespondingRedefinableTypeMemberNotFound = 279,
+    ConstructorCannotBeDeclaredAsBasic = 280,
+    ConstructorCannotBeDeclaredAsRedefinable = 281,
+    ConstructorCannotBeDeclaredAsOverridden = 282,
+    AsyncFunctionCanOnlyBeCalledFromFunctionMarkedWithAsyncModifier = 283,
+    TagNotFound = 284,
+    TypeOrFunctionNameExpected = 285,
+    PackageNameOrAliasExpected = 286,
+    ExpressionCanBeNone = 287,
+    TargetVariableExpressionInTheAssignmentStatementCannotContainQuestionOperator = 288,
+    UnreachableCode = 289,
+    RecursionOccurredWhileCalculatingTheTypeOfTheExpression = 290,
+    ScopeAlreadyContainsDeclarationWithTheSameName = 291,
+    ParameterName0ConflictsWithAutomaticallyGeneratedVariableName = 292,
+    VariableIsUsedBeforeItsDeclaration = 293,
+    VariableMayNotHasBeenAssignedBeforeUsage = 294,
+    CannotFindTsLibDirectoryBaseSearchPaths0 = 301,
+    SourceFile0IsNotPartOfThePackageAndWontBeLoaded = 302,
+    ProgramWithoutMainPackageCannotBeCompiled = 303,
+    ErrorsInJsonConfigurationFile = 304,
+    StandardPackage0NotFound = 305,
+    Declaration0NotFoundInStandardPackage1 = 306
 }

package/build/types/emitter/IrBuilder.d.ts

@@ -92,6 +92,7 @@ export declare class IrBuilder {
     private convertDereferencedVariableAccess;
     private buildReferenceExpression;
     private buildWhenTernaryExpression;
+    private buildConditionalExpression;
     private buildTextTemplateLiteral;
     private buildTokenExpression;
     private buildKeywordExpression;