@artel/artc 0.6.25227 → 0.6.25229

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

@@ -95,6 +95,8 @@ export declare class Analyzer {
     private readonly _namedDeclarationsUsageCountResults;
     private readonly _controlFlowGraphs;
     private readonly _diagnosticsComputedLazily;
+    private readonly _diagnosticsComputedLazilyAcceptor;
+    private readonly _sourcePackageMemberConflictsDiagnostics;
     get tsInterop(): TsInteropContext;
     constructor(compilation: project.Compilation, tsInteropInputs: TsInteropInputs);
     getProjectSourceFile(node: tree.SourceFile): project.SourceFile;
@@ -259,9 +261,9 @@ export declare class Analyzer {
     createDiagnostic(code: DiagnosticCode, location: DiagnosticLocation | undefined, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
     createNodeDiagnosticLocation(node: tree.Node): DiagnosticLocation;
     getDeclaredTypeMemberEntities(node: tree.TypeMemberDeclarationBlock): DeclaredTypeMemberEntities;
-    getRedefinableMethodOfOriginalTypeForRedefinableMethodOfAliasType(entity: e.MethodEntity): e.MethodEntity | undefined;
-    checkBodyOfRedefinableAliasTypeMethod(node: tree.MethodDeclaration, diagnostics?: DiagnosticAcceptor): {
-        redefinableMethodOfOriginalType: e.MethodEntity;
+    getBasicMethodOfOriginalTypeForBasicMethodOfAliasType(entity: e.MethodEntity): e.MethodEntity | undefined;
+    checkBodyOfBasicAliasTypeMethod(node: tree.MethodDeclaration, diagnostics?: DiagnosticAcceptor): {
+        basicMethodOfOriginalType: e.MethodEntity;
     } | undefined;
     getControlFlowGraph(sourceFile: project.SourceFile): controlFlow.GraphBuildResult;
     createAmbiguousEntityAccessDiagnostic(entities: readonly WithLocalization<e.Entity>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
@@ -272,8 +274,10 @@ export declare class Analyzer {
     createAmbiguousTypeMemberAccessLazyDiagnostic(members: readonly WithLocalization<types.TypeMember>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
     createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly WithLocalization<semanticContext.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
     createAmbiguousNamedScopeDeclarationAccessLazyDiagnostic(declarations: readonly WithLocalization<semanticContext.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
-    addNodeDiagnosticComputedLazily(node: tree.Node, diagnostic: Diagnostic): void;
+    addDiagnosticComputedLazily(diagnostic: Diagnostic): void;
+    getAcceptorForDiagnosticsComputedLazily(): DiagnosticAcceptor;
     getDiagnosticsComputedLazily(sourceFile: project.SourceFile): readonly Diagnostic[];
+    validateSourcePackageMemberConflicts(pkg: project.ProgramPackage): readonly Diagnostic[];
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -327,7 +331,6 @@ declare class Type {
     private ofMemberAccessExpression;
     private ofReferenceExpression;
     private ofDereferenceExpression;
-    private ofWhenTernaryExpression;
     private ofConditionalExpression;
     private ofTextTemplateLiteral;
     private ofIdentifierExpression;
@@ -360,6 +363,10 @@ declare class ReturnType {
     ofFunctionLiteral(node: tree.FunctionLiteral): types.Type;
     ofMethodDeclaration(node: tree.MethodDeclaration): types.Type;
     ofOperatorDeclaration(node: tree.OperatorDeclaration): types.Type;
+    ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): types.Type;
+    ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): types.Type;
+    ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): types.Type;
+    ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): types.Type;
 }
 declare class Entity {
     private readonly _analyzer;

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

@@ -7,12 +7,17 @@ export declare class DeclarationsUsageCounter {
     private readonly _analyzer;
     private readonly _sourceFile;
     private readonly _cancellationToken;
-    private readonly _usageCountByEntity;
+    private readonly _usageInfoByEntity;
     constructor(analyzer: Analyzer, sourceFile: tree.SourceFile, cancellationToken: CancellationToken | undefined);
     count(): Promise<DeclarationsUsageCountResult>;
+    private recordUsage;
 }
 export declare class DeclarationsUsageCountResult {
     private readonly _usageCountByEntity;
-    constructor(_usageCountByEntity: ReadonlyMap<Entity, number>);
-    getUsageCount(entity: NamedEntity): number;
+    constructor(_usageCountByEntity: ReadonlyMap<Entity, DeclarationUsageInfo>);
+    getUsageInfo(entity: NamedEntity): DeclarationUsageInfo;
+}
+export interface DeclarationUsageInfo {
+    readonly usageCount: number;
+    readonly hasGetAccess: boolean;
 }

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

@@ -18,6 +18,8 @@ export declare class DiagnosticCollector {
     constructor(analyzer: Analyzer, sourceFile: project.SourceFile, cancellationToken: CancellationToken | undefined);
     collect(): Promise<Diagnostic[]>;
     private collectNodeDiagnostics;
+    private checkFunctionLiteral;
+    private checkFunctionBlockLiteral;
     private checkDereferenceExpression;
     private checkIndexedAccessExpression;
     private checkCallExpression;
@@ -44,9 +46,11 @@ export declare class DiagnosticCollector {
     private checkPossibleGeneratorFunctionReturnType;
     private checkReturnStatement;
     private checkYieldStatement;
+    private checkPackageMemberBodyPresence;
+    private getPackageMemberBodyRequirementReason;
     private checkTypeMemberBodyPresence;
-    private tryGetTypeMemberDeclarationEntity;
-    private isAspectTypeMemberDeclaration;
+    private getTypeMemberBodyRequirementReason;
+    private isBasicEntity;
     private checkIdentifierExpression;
     private checkLocalVariableUsedBeforeDeclaration;
     private checkLocalVariableIsUsedBeforeBeingAssigned;
@@ -74,6 +78,9 @@ export declare class DiagnosticCollector {
     private checkTypeArgumentCount;
     private checkParameterDeclaration;
     private checkIfVariableIsUnused;
+    private checkIfNestedFunctionIsUnused;
+    private checkIfTypeParameterIsUnused;
+    private checkAllCodePathsReturnOrResultVariableIsAssigned;
     private addDiagnostic;
     private addDiagnostics;
     private addMaybeLazyDiagnostic;

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

@@ -7,10 +7,9 @@ export declare enum ModifierFlags {
     HiddenInPackage = 16,
     Basic = 32,
     Static = 64,
-    Redefinable = 128,
-    Abstract = 256,
-    Redefined = 512,
-    Async = 1024,
-    Const = 2048,
-    NotComputed = 4096
+    Abstract = 128,
+    Redefined = 256,
+    Async = 512,
+    Const = 1024,
+    NotComputed = 2048
 }

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

@@ -13,6 +13,7 @@ export declare class NodeTypeUtils {
     static isVariableDeclaration(node: tree.Node): node is VariableDeclaration;
     static isVariantTypeDeclaration(node: tree.Node): node is VariantTypeDeclaration;
     static isNoneLiteral(node: tree.Node): boolean;
+    static isSubprogramDeclarationOrLiteral(node: tree.Node): node is SubprogramDeclarationOrLiteral;
 }
 export type PackageTypeDeclaration = tree.PackageAliasTypeDeclaration | tree.PackageFunctionTypeDeclaration | tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration;
 export type StructuredTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.AnonymousStructuredTypeDeclaration;
@@ -28,6 +29,5 @@ export type PackageVariableAccessorDeclaration = tree.PackageVariableGetterDecla
 export type FieldAccessorDeclaration = tree.FieldGetterDeclaration | tree.FieldSetterDeclaration;
 export type IndexedElementAccessorDeclaration = tree.IndexedElementGetterDeclaration | tree.IndexedElementSetterDeclaration;
 export type DereferencedVariableAccessorDeclaration = tree.DereferencedVariableGetterDeclaration | tree.DereferencedVariableSetterDeclaration;
-export type SubprogramDeclaration = tree.FunctionBlockParent;
 export type RegularOrBlockFunctionLiteral = tree.FunctionLiteral | tree.FunctionBlockLiteral;
-export type SubprogramDeclarationOrLiteral = SubprogramDeclaration | RegularOrBlockFunctionLiteral;
+export type SubprogramDeclarationOrLiteral = tree.FunctionBlockParent;

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

@@ -0,0 +1,24 @@
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { OriginalPackageMembers } from '../entities/PackageMembers.js';
+import { ProgramPackage } from '../project/SourcePackage.js';
+import { Analyzer } from './Analyzer.js';
+export declare class PackageMemberNameConflictsValidator {
+    private readonly _analyzer;
+    private readonly _members;
+    private readonly _diagnostics;
+    constructor(_analyzer: Analyzer, _members: OriginalPackageMembers);
+    validate(): readonly Diagnostic[];
+    private validateFunctionNameConflicts;
+    private areFunctionSignaturesEqual;
+    private validateTypeNameConflicts;
+    private typeParameterCountsIntersect;
+    private createAndAddNameConflictDiagnosticsForAllEntities;
+    private createAndAddNameConflictDiagnostic;
+    private getDiagnosticLocation;
+}
+export declare class SourcePackageMemberConflictsValidator {
+    private readonly _analyzer;
+    private readonly _package;
+    constructor(_analyzer: Analyzer, _package: ProgramPackage);
+    validate(): readonly Diagnostic[];
+}

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

@@ -1,15 +1,20 @@
 import { SearchName } from '../common/index.js';
+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 readonly _analyzer;
     private readonly _namedMembers;
     private readonly _typeExtensions;
     private readonly _declarationsByName;
     get declarationsByName(): ReadonlyMap<string, readonly NamedSourceFileMemberEntity[]>;
-    constructor(namedMembers: readonly NamedSourceFileMemberEntity[], typeExtensions: readonly TypeExtensionEntity[]);
+    constructor(analyzer: Analyzer, namedMembers: readonly NamedSourceFileMemberEntity[], typeExtensions: readonly TypeExtensionEntity[]);
     getNamedDeclarations(): readonly NamedSourceFileMemberEntity[];
     getNamedDeclarationsByName(name: SearchName): readonly NamedSourceFileMemberEntity[];
     getPackageAliases(): readonly PackageAliasEntity[];
     getPackageAliasesByName(name: SearchName): readonly PackageAliasEntity[];
     getTypeExtensions(): readonly TypeExtensionEntity[];
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+    private getDiagnosticLocation;
 }
 export type NamedSourceFileMemberEntity = PackageTypeEntity | PackageVariableEntity | PackageFunctionEntity | PackageAliasEntity;

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

@@ -1,6 +1,7 @@
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { PackageVariableEntity } from '../entities/VariableEntity.js';
 import * as tree from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
 export declare class SourcePackageMembersCreator {
-    static createMembersWithCompoundDeclarations(analyzer: Analyzer, memberList: tree.PackageMemberDeclarationList, resultingComputedVariables: Map<tree.Node, PackageVariableEntity>): void;
+    static createMembersWithCompoundDeclarations(analyzer: Analyzer, memberList: tree.PackageMemberDeclarationList, resultingComputedVariables: Map<tree.Node, PackageVariableEntity>, diagnostics: DiagnosticAcceptor | undefined): void;
 }

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

@@ -4,6 +4,8 @@ export declare class TypeInferrer {
     private readonly _analyzer;
     private _getType;
     private _typeInferringState;
+    private _hasDetectedInferenceCycle;
+    get hasDetectedInferenceCycle(): boolean;
     constructor(analyzer: Analyzer, getType: () => types.Type);
     inferType(): types.Type;
 }

package/build/types/analysis/control-flow/GraphBuilder.d.ts

@@ -1,10 +1,12 @@
 import { Diagnostic } from '../../diagnostic/Diagnostic.js';
 import { SourceFile } from '../../project/SourceFile.js';
+import { SubprogramDeclarationOrLiteral } from '../NodeTypeUtils.js';
 import { NarrowableReferenceExpression } from './NarrowableExpression.js';
 import { Node } from './Nodes.js';
 export declare class GraphBuilder {
     private readonly _sourceFile;
     private readonly _controlFlowNodeByReference;
+    private readonly _controlFlowNodesEndingSubprogram;
     private readonly _unreachableCodeDiagnostics;
     private _isInRebuildingFinallyClauseGraphMode;
     private _currentPredecessor;
@@ -12,6 +14,7 @@ export declare class GraphBuilder {
     private _currentBreakLoopTarget;
     private _currentErrorTarget;
     private _currentReturnTarget;
+    private _currentRangeWithReportedUnreachableCodeDiagnostic;
     constructor(sourceFile: SourceFile);
     build(): GraphBuildResult;
     private visitNode;
@@ -27,7 +30,6 @@ export declare class GraphBuilder {
     private visitReturnStatement;
     private visitErrorStatement;
     private visitLocalVariableDeclaration;
-    private visitWhenTernaryExpression;
     private visitConditionalExpression;
     private visitCondition;
     private visitBinaryExpression;
@@ -39,6 +41,7 @@ export declare class GraphBuilder {
 }
 export declare class GraphBuildResult {
     readonly controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>;
+    readonly controlFlowNodesEndingSubprogram: ReadonlyMap<SubprogramDeclarationOrLiteral, Node>;
     readonly unreachableCodeDiagnostics: readonly Diagnostic[];
-    constructor(controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>, unreachableCodeDiagnostics: readonly Diagnostic[]);
+    constructor(controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>, controlFlowNodesEndingSubprogram: ReadonlyMap<SubprogramDeclarationOrLiteral, Node>, unreachableCodeDiagnostics: readonly Diagnostic[]);
 }

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

@@ -1,6 +1,6 @@
 import { FieldWithInitializerSemanticContext } from './FieldWithInitializerSemanticContext.js';
-import { CatchClauseSemanticContext, ForStatementSemanticContext, FunctionBlockSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterSemanticContext, SubprogramTypeParameterSemanticContext } from './SemanticContextValidatingNameConflicts.js';
 import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
+import { CatchClauseSemanticContext, ForStatementSemanticContext, FunctionBlockSemanticContext, SpecialLocalDeclarationSemanticContext, StatementBlockSemanticContext, SubprogramParameterSemanticContext, SubprogramTypeParameterSemanticContext } from './SubprogramBodyAndParametersSemanticContext.js';
 import { OutermostSemanticContextOfSubprogram } from './SubprogramSemanticContext.js';
 import { OutermostSemanticContextOfType, ParametersOfFunctionTypeSemanticContext, TypeBodySemanticContext, TypeExtensionBodySemanticContext, TypeParametersOfTypeSemanticContext } from './TypeSemanticContext.js';
 /**

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

@@ -7,9 +7,7 @@ import { Analyzer } from '../Analyzer.js';
 import { FoundNamedDeclaration } from '../FoundDeclaration.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';
-import { TryStatementContextKind } from './SemanticContextBase.js';
 import { SemanticContextWithParent } from './SemanticContextWithParent.js';
-import { OutermostSemanticContextOfSubprogram } from './SubprogramSemanticContext.js';
 export declare abstract class SemanticContextValidatingNameConflictsBase extends SemanticContextWithParent implements ISemanticContextValidatingNameConflicts {
     abstract readonly outer: SemanticContext;
     abstract readonly node: tree.Node;
@@ -33,91 +31,14 @@ export declare abstract class SemanticContextValidatingNameConflictsBase extends
     getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
     getOwnNamedDeclarationsByName(name: SearchName, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
     validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
-    getMemberEntityDictionary(): ReadonlyMap<string, readonly MemberOfSemanticContextValidatingNameConflicts[]>;
+    private getMemberEntityDictionary;
     private validateNestedFunctionsConflicts;
     private areNestedFunctionSignaturesEqual;
     private createNamedDeclarations;
     private createTypesOrContainerWithTypes;
 }
-export type SubprogramTypeParameterSemanticContextParent = OutermostSemanticContextOfSubprogram;
-export declare class SubprogramTypeParameterSemanticContext extends SemanticContextValidatingNameConflictsBase {
-    readonly kind = "subprogram-type-parameter";
-    readonly outer: SubprogramTypeParameterSemanticContextParent;
-    readonly node: tree.TypeParameterClause;
-    protected readonly asContext: SemanticContext;
-    constructor(analyzer: Analyzer, node: tree.TypeParameterClause, outer: SubprogramTypeParameterSemanticContextParent);
-    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
-    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
-    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
-}
-export type SubprogramParameterSemanticContextParent = SubprogramTypeParameterSemanticContext | OutermostSemanticContextOfSubprogram;
-export declare abstract class SubprogramParameterSemanticContext extends SemanticContextValidatingNameConflictsBase {
-    readonly kind = "subprogram-parameter";
-    readonly outer: SubprogramParameterSemanticContextParent;
-    constructor(analyzer: Analyzer, outer: SubprogramParameterSemanticContextParent);
-}
-export declare class ExplicitSubprogramParameterSemanticContext extends SubprogramParameterSemanticContext {
-    readonly node: tree.ParameterList;
-    protected readonly asContext: SemanticContext;
-    constructor(analyzer: Analyzer, node: tree.ParameterList, outer: SubprogramParameterSemanticContextParent);
-    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
-    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
-    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
-}
-export type BlockSemanticContext = StatementBlockSemanticContext | FunctionBlockSemanticContext;
-export type StatementBlockSemanticContextParent = StatementBlockSemanticContext | FunctionBlockSemanticContext | ForStatementSemanticContext | CatchClauseSemanticContext;
-export declare class StatementBlockSemanticContext extends SemanticContextValidatingNameConflictsBase {
-    readonly kind = "statement-block";
-    readonly outer: StatementBlockSemanticContextParent;
-    readonly node: tree.StatementBlock;
-    protected readonly asContext: SemanticContext;
-    constructor(analyzer: Analyzer, node: tree.StatementBlock, outer: StatementBlockSemanticContextParent);
-    getTryStatementContext(): TryStatementContextKind | undefined;
-    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
-    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
-}
-export type FunctionBlockSemanticContextParent = SubprogramParameterSemanticContext | OutermostSemanticContextOfSubprogram | SpecialLocalDeclarationSemanticContext;
-export declare class FunctionBlockSemanticContext extends SemanticContextValidatingNameConflictsBase {
-    readonly kind = "function-block";
-    readonly outer: FunctionBlockSemanticContextParent;
-    readonly node: tree.FunctionBlock;
-    protected readonly asContext: SemanticContext;
-    constructor(analyzer: Analyzer, node: tree.FunctionBlock, outer: FunctionBlockSemanticContextParent);
-    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
-    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
-}
-export type SpecialLocalDeclarationSemanticContextParent = SubprogramParameterSemanticContext | OutermostSemanticContextOfSubprogram;
-export declare class SpecialLocalDeclarationSemanticContext extends SemanticContextValidatingNameConflictsBase {
-    readonly kind = "special-local-declaration";
-    readonly outer: SpecialLocalDeclarationSemanticContextParent;
-    readonly node: tree.FunctionBlock;
-    protected readonly asContext: SemanticContext;
-    constructor(analyzer: Analyzer, node: tree.FunctionBlock, outer: SpecialLocalDeclarationSemanticContextParent);
-    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
-    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
-}
-export declare class ForStatementSemanticContext extends SemanticContextValidatingNameConflictsBase {
-    readonly kind = "for-statement";
-    readonly outer: BlockSemanticContext;
-    readonly node: tree.ForStatement;
-    protected readonly asContext: SemanticContext;
-    constructor(analyzer: Analyzer, node: tree.ForStatement, outer: BlockSemanticContext);
-    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
-    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
-}
-export declare class CatchClauseSemanticContext extends SemanticContextValidatingNameConflictsBase {
-    readonly kind = "catch-clause";
-    readonly outer: BlockSemanticContext;
-    readonly node: tree.CatchClause;
-    protected readonly asContext: SemanticContext;
-    constructor(analyzer: Analyzer, node: tree.CatchClause, outer: BlockSemanticContext);
-    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
-    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
-}
-export type SemanticContextValidatingNameConflicts = StatementBlockSemanticContext | ForStatementSemanticContext | CatchClauseSemanticContext | SpecialLocalDeclarationSemanticContext | SubprogramParameterSemanticContext | SubprogramTypeParameterSemanticContext;
 interface ISemanticContextValidatingNameConflicts {
     validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
-    getMemberEntityDictionary(): ReadonlyMap<string, readonly MemberOfSemanticContextValidatingNameConflicts[]>;
 }
 export type MemberOfSemanticContextValidatingNameConflicts = LocalVariableEntity | ParameterVariableEntity | NestedFunctionEntity | TypeParameterEntity;
 export type MemberOfSemanticContextValidatingNameConflictsForTypeLookup = TypeParameterEntity;

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

@@ -33,7 +33,7 @@ export declare class SourceFileSemanticContext extends SemanticContextBase {
     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>[];
+    getOwnNamedDeclarationsByName(name: SearchName, _noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
     getOwnTypeExtensionsByType(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
     private convertPackageMemberToNamedDeclaration;
     private convertPackageAliasToTypeOrContainerWithTypes;

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

@@ -0,0 +1,89 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { SemanticContext } from './SemanticContext.js';
+import { TryStatementContextKind } from './SemanticContextBase.js';
+import { MemberOfSemanticContextValidatingNameConflicts, MemberOfSemanticContextValidatingNameConflictsForTypeLookup, SemanticContextValidatingNameConflictsBase } from './SemanticContextValidatingNameConflicts.js';
+import { OutermostSemanticContextOfSubprogram } from './SubprogramSemanticContext.js';
+export type SubprogramTypeParameterSemanticContextParent = OutermostSemanticContextOfSubprogram;
+export declare class SubprogramTypeParameterSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "subprogram-type-parameter";
+    readonly outer: SubprogramTypeParameterSemanticContextParent;
+    readonly node: tree.TypeParameterClause;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.TypeParameterClause, outer: SubprogramTypeParameterSemanticContextParent);
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export type SubprogramParameterSemanticContextParent = SubprogramTypeParameterSemanticContext | OutermostSemanticContextOfSubprogram;
+export declare abstract class SubprogramParameterSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "subprogram-parameter";
+    readonly outer: SubprogramParameterSemanticContextParent;
+    constructor(analyzer: Analyzer, outer: SubprogramParameterSemanticContextParent);
+}
+export declare class ExplicitSubprogramParameterSemanticContext extends SubprogramParameterSemanticContext {
+    readonly node: tree.ParameterList;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.ParameterList, outer: SubprogramParameterSemanticContextParent);
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+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 type BlockSemanticContext = StatementBlockSemanticContext | FunctionBlockSemanticContext;
+export type StatementBlockSemanticContextParent = StatementBlockSemanticContext | FunctionBlockSemanticContext | ForStatementSemanticContext | CatchClauseSemanticContext;
+export declare class StatementBlockSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "statement-block";
+    readonly outer: StatementBlockSemanticContextParent;
+    readonly node: tree.StatementBlock;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.StatementBlock, outer: StatementBlockSemanticContextParent);
+    getTryStatementContext(): TryStatementContextKind | undefined;
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export type FunctionBlockSemanticContextParent = SubprogramParameterSemanticContext | OutermostSemanticContextOfSubprogram | SpecialLocalDeclarationSemanticContext;
+export declare class FunctionBlockSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "function-block";
+    readonly outer: FunctionBlockSemanticContextParent;
+    readonly node: tree.FunctionBlock;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.FunctionBlock, outer: FunctionBlockSemanticContextParent);
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export type SpecialLocalDeclarationSemanticContextParent = SubprogramParameterSemanticContext | OutermostSemanticContextOfSubprogram;
+export declare class SpecialLocalDeclarationSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "special-local-declaration";
+    readonly outer: SpecialLocalDeclarationSemanticContextParent;
+    readonly node: tree.FunctionBlock;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.FunctionBlock, outer: SpecialLocalDeclarationSemanticContextParent);
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export declare class ForStatementSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "for-statement";
+    readonly outer: BlockSemanticContext;
+    readonly node: tree.ForStatement;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.ForStatement, outer: BlockSemanticContext);
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}
+export declare class CatchClauseSemanticContext extends SemanticContextValidatingNameConflictsBase {
+    readonly kind = "catch-clause";
+    readonly outer: BlockSemanticContext;
+    readonly node: tree.CatchClause;
+    protected readonly asContext: SemanticContext;
+    constructor(analyzer: Analyzer, node: tree.CatchClause, outer: BlockSemanticContext);
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
+}

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

@@ -7,7 +7,6 @@ import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, Func
 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';
@@ -36,13 +35,6 @@ export declare class FunctionSemanticContext extends OutermostSemanticContextOfS
     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;

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

@@ -10,6 +10,7 @@ import { TypeMemberLookup } from '../TypeMemberLookup.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';
 import { SubprogramInfo, TypeOrTypeExtension } from './SemanticContextBase.js';
+import { MemberOfSemanticContextValidatingNameConflicts, MemberOfSemanticContextValidatingNameConflictsForTypeLookup, SemanticContextValidatingNameConflictsBase } from './SemanticContextValidatingNameConflicts.js';
 import { SemanticContextWithParent } from './SemanticContextWithParent.js';
 import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
 export type TypeDeclarationCreatingSemanticContext = StructuredTypeDeclaration | VariantTypeDeclaration | FunctionTypeDeclaration | tree.PackageAliasTypeDeclaration;
@@ -35,23 +36,15 @@ export declare class OutermostSemanticContextOfType extends SemanticContextWithP
     private getContainingType;
 }
 type TypeDeclarationWithTypeParameters = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.PackageFunctionTypeDeclaration;
-export declare class TypeParametersOfTypeSemanticContext extends SemanticContextWithParent {
+export declare class TypeParametersOfTypeSemanticContext extends SemanticContextValidatingNameConflictsBase {
     readonly kind = "type-parameter-of-type";
     readonly outer: OutermostSemanticContextOfType;
+    readonly node: TypeDeclarationWithTypeParameters;
     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;
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
 }
 declare abstract class TypeOrExtensionBodySemanticContext extends SemanticContextWithParent {
     protected abstract memberLookup: TypeMemberLookup;
@@ -89,21 +82,13 @@ export declare class TypeExtensionBodySemanticContext extends TypeOrExtensionBod
     getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
 }
 export type ParameterOfFunctionTypeSemanticContextParent = TypeParametersOfTypeSemanticContext | OutermostSemanticContextOfType;
-export declare class ParametersOfFunctionTypeSemanticContext extends SemanticContextWithParent {
+export declare class ParametersOfFunctionTypeSemanticContext extends SemanticContextValidatingNameConflictsBase {
     readonly kind = "parameters-of-function-type";
     readonly outer: ParameterOfFunctionTypeSemanticContextParent;
+    readonly node: tree.FunctionTypeDeclarationBody;
     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;
+    protected createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
+    protected createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
 }
 export {};

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

@@ -5,5 +5,6 @@ export * from './SemanticContextBase.js';
 export * from './SemanticContextBuilder.js';
 export * from './SemanticContextValidatingNameConflicts.js';
 export * from './SourceFileSemanticContext.js';
+export * from './SubprogramBodyAndParametersSemanticContext.js';
 export * from './SubprogramSemanticContext.js';
 export * from './TypeSemanticContext.js';

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

@@ -4,4 +4,5 @@ export declare class Cached<T> {
     private _isEvaluating;
     getOrInsertWith(fn: () => T): T;
     clear(): void;
+    getCachedValue(): T | undefined;
 }