@artel/artc 0.6.25217 → 0.6.25219

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

@@ -7,13 +7,13 @@ export declare class Lookup {
     private readonly _scopeChain;
     private readonly _hidingMatcher;
     constructor(_scopeChain: ScopeChain, _hidingMatcher: IEntityHidingMatcher);
-    getTypesOrContainersWithTypes(): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
-    getTypesOrContainersWithTypesByName(name: SearchName): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
-    getNamedDeclarations(): FoundNamedDeclaration<NamedDeclaration>[];
-    getNamedDeclarationsByName(name: SearchName): FoundNamedDeclaration<NamedDeclaration>[];
-    getOperators(): FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(kind: OperatorKind): FoundAnonymousDeclaration<types.Operator>[];
-    getTypeExtensionsByType(type: TypeEntity): TypeExtensionEntity[];
+    getTypesOrContainersWithTypes(): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getTypesOrContainersWithTypesByName(name: SearchName): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getNamedDeclarations(): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getTypeExtensionsByType(type: TypeEntity): readonly TypeExtensionEntity[];
     private checkTypeOrPackageDeclarationShadowing;
     private checkNamedDeclarationShadowing;
     private checkOperatorShadowing;
@@ -23,5 +23,6 @@ export declare class ScopeChain {
     private constructor();
     addFirst(scope: IScope): ScopeChain;
     toQuery(): Query<IScope>;
+    enumerateScopes(): Iterable<IScope>;
     static withSingleScope(scope: IScope): ScopeChain;
 }

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

@@ -0,0 +1,16 @@
+export declare enum ModifierFlags {
+    None = 0,
+    HiddenWithoutLevel = 1,
+    HiddenInType = 2,
+    HiddenInHierarchy = 4,
+    HiddenInFile = 8,
+    HiddenInPackage = 16,
+    Basic = 32,
+    Static = 64,
+    Redefinable = 128,
+    Abstract = 256,
+    Redefined = 512,
+    Async = 1024,
+    Const = 2048,
+    NotComputed = 4096
+}

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

@@ -9,7 +9,6 @@ export declare class NamedTypeSpecifierResolver {
     private readonly _node;
     constructor(_analyzer: Analyzer, _node: NamedTypeSpecifier);
     resolve(): NamedTypeSpecifierResolutionResult;
-    private convertNamedTypeToTypeDeclaration;
     private resolveTypeOverload;
 }
 export declare class NamedTypeSpecifierResolutionResult {

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

@@ -15,6 +15,7 @@ export declare class NodeTypeUtils {
 export type PackageTypeDeclaration = tree.PackageAliasTypeDeclaration | tree.PackageMethodTypeDeclaration | tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration;
 export type StructuredTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.AnonymousStructuredTypeDeclaration;
 export type VariantTypeDeclaration = tree.PackageVariantTypeDeclaration | tree.AnonymousVariantTypeDeclaration;
+export declare function isVariantTypeDeclaration(node: tree.Node): node is VariantTypeDeclaration;
 export type MethodTypeDeclaration = tree.PackageMethodTypeDeclaration | tree.AnonymousMethodTypeDeclaration;
 export type MethodDeclaration = tree.PackageMethodDeclaration | tree.NestedMethodDeclaration | tree.TypeMethodDeclaration;
 export type TypeDeclaration = StructuredTypeDeclaration | VariantTypeDeclaration | MethodTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeParameterDeclaration;

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

@@ -5,8 +5,8 @@ import { Analyzer } from './Analyzer.js';
 export declare class Resolver<TCandidate extends ICandidate<TValueParameter>, TValueParameter extends IValueParameter> {
     private readonly _analyzer;
     constructor(_analyzer: Analyzer);
-    resolveByCallExpression(candidates: Iterable<TCandidate>, node: CallExpression): Iterable<TCandidate>;
-    resolveByTargetType(candidates: Iterable<TCandidate>, targetType: types.MethodType): Iterable<TCandidate>;
+    resolveByCallExpression(candidates: readonly TCandidate[], node: CallExpression): readonly TCandidate[];
+    resolveByTargetType(candidates: readonly TCandidate[], targetType: types.MethodType): readonly TCandidate[];
 }
 export interface ICandidate<TValueParameter extends IValueParameter> {
     getValueParameters(): readonly TValueParameter[];

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

@@ -1,10 +1,10 @@
 import { Analyzer } from '../analysis/index.js';
-import * as matcher from './CallArgumentsToParametersMatcher.js';
-export declare class OverloadResolver<TSignature extends matcher.ISignature<TParameter>, TParameter extends matcher.ISignatureParameter, TCallArgument extends matcher.ICallArgument> {
+import * as matcher from './ArgumentsToParametersMatcher.js';
+export declare class OverloadResolver<TSignature extends matcher.ISignature<TParameter>, TParameter extends matcher.ISignatureParameter, TArgument extends matcher.IArgument> {
     private readonly _analyzer;
     private readonly _signatures;
-    private readonly _callArguments;
-    constructor(_analyzer: Analyzer, _signatures: readonly TSignature[], _callArguments: readonly TCallArgument[]);
+    private readonly _arguments;
+    constructor(_analyzer: Analyzer, _signatures: readonly TSignature[], _arguments: readonly TArgument[]);
     resolveOverload(): TSignature[];
     private tryChooseBestSignature;
     private chooseBetterTargetType;

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

@@ -1,6 +1,5 @@
-import { Query, SearchName } from '../common/index.js';
-import { NamedMember } from '../entities/PackageMembers.js';
-import { IEntityHidingMatcher, PackageEntity, TypeEntity, TypeExtensionEntity } from '../entities/index.js';
+import { SearchName } from '../common/index.js';
+import { IEntityHidingMatcher, NamedPackageMemberEntity, PackageEntity, TypeEntity, TypeExtensionEntity } from '../entities/index.js';
 import { FoundNamedDeclaration } from './FoundDeclaration.js';
 import { LocalizationContext } from './LocalizationContext.js';
 export declare class PackageMemberLookup {
@@ -9,7 +8,7 @@ export declare class PackageMemberLookup {
     private readonly _translatedMembers;
     private get translatedMembers();
     constructor(_package: PackageEntity, _localizationContext: LocalizationContext | undefined);
-    getNamedMembers(hidingMatcher?: IEntityHidingMatcher): Query<FoundNamedDeclaration<NamedMember>>;
-    getNamedMembersByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): Query<FoundNamedDeclaration<NamedMember>>;
-    getTypeExtensions(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): Query<TypeExtensionEntity>;
+    getNamedMembers(hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedPackageMemberEntity>[];
+    getNamedMembersByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedPackageMemberEntity>[];
+    getTypeExtensions(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): readonly TypeExtensionEntity[];
 }

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

@@ -1,11 +1,11 @@
+import { AccessKind } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { PackageTypeEntity, PackageVariableEntity, VariantEntity } from '../entities/index.js';
+import { PackageTypeEntity, PackageVariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { AccessedMethod } from './AccessedMethod.js';
 import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import * as variableAccess from './VariableAccess.js';
 import { Analyzer, TargetTypeHint } from './index.js';
 export declare class Resolver {
     private readonly _semanticContext;
@@ -31,14 +31,22 @@ export declare class Resolver {
 export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly diagnostic?: Diagnostic | undefined;
-    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined);
+    /**
+     * Может ли измениться результат, если посчитать его с другим целевым типом?
+     */
+    readonly dependsOnTargetType: boolean;
+    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
+    /**
+     * Может ли измениться результат, если посчитать его с другим целевым типом?
+     */
+    dependsOnTargetType?: boolean);
 }
-export type Meaning = Meaning_packageVariableAccess | Meaning_packageMethodAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_variantAccess | Meaning_staticVariableAccess | Meaning_staticMethodAccess | Meaning_instanceVariableAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_unresolved;
+export type Meaning = Meaning_packageVariableAccess | Meaning_packageMethodAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_staticVariableAccess | Meaning_staticMethodAccess | Meaning_instanceVariableAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_unresolved;
 declare class Meaning_packageVariableAccess {
     readonly variable: FoundNamedDeclaration<PackageVariableEntity>;
-    readonly access: variableAccess.VariableAccess;
+    readonly accessKind: AccessKind;
     readonly kind = "package-variable-access";
-    constructor(variable: FoundNamedDeclaration<PackageVariableEntity>, access: variableAccess.VariableAccess);
+    constructor(variable: FoundNamedDeclaration<PackageVariableEntity>, accessKind: AccessKind);
 }
 declare class Meaning_packageMethodAccess {
     readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];
@@ -59,18 +67,12 @@ declare class Meaning_packageNameSegmentAccess {
     readonly kind = "package-name-segment-access";
     constructor(packageTreeNode: PackageNameTreeNode);
 }
-declare class Meaning_variantAccess {
-    readonly type: types.VariantType;
-    readonly variant: FoundNamedDeclaration<VariantEntity>;
-    readonly kind = "variant-access";
-    constructor(type: types.VariantType, variant: FoundNamedDeclaration<VariantEntity>);
-}
 declare class Meaning_staticVariableAccess {
     readonly type: types.Type;
     readonly variable: FoundNamedDeclaration<types.Variable>;
-    readonly access: variableAccess.VariableAccess;
+    readonly accessKind: AccessKind;
     readonly kind = "static-variable-access";
-    constructor(type: types.Type, variable: FoundNamedDeclaration<types.Variable>, access: variableAccess.VariableAccess);
+    constructor(type: types.Type, variable: FoundNamedDeclaration<types.Variable>, accessKind: AccessKind);
 }
 declare class Meaning_staticMethodAccess {
     readonly type: types.Type;
@@ -82,9 +84,9 @@ declare class Meaning_staticMethodAccess {
 }
 declare class Meaning_instanceVariableAccess {
     readonly variable: FoundNamedDeclaration<types.Variable>;
-    readonly access: variableAccess.VariableAccess;
+    readonly accessKind: AccessKind;
     readonly kind = "instance-variable-access";
-    constructor(variable: FoundNamedDeclaration<types.Variable>, access: variableAccess.VariableAccess);
+    constructor(variable: FoundNamedDeclaration<types.Variable>, accessKind: AccessKind);
 }
 declare class Meaning_instanceMethodAccess {
     readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];

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

@@ -1,5 +1,5 @@
 import { Name, PackageLocale, SearchName } from '../common/index.js';
-import { AliasTypeEntity, EntityHidingLevel, IEntityHidingMatcher, MethodEntity, NamedTypeEntity, OperatorKind, PackageAliasEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, TypeEntity, TypeExtensionEntity, TypeParameterEntity, VariableEntity, VariantEntity } from '../entities/index.js';
+import { EntityHidingLevel, IEntityHidingMatcher, MethodEntity, NamedTypeEntity, OperatorKind, PackageAliasEntity, TypeEntity, TypeExtensionEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
@@ -8,105 +8,16 @@ import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { Lookup } from './Lookup.js';
 import { TypeMemberLookup } from './TypeMemberLookup.js';
 export interface IScope {
-    getTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
-    getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
-    getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
-    getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
-    getOperators(hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
-    getTypeExtensionsByType(typeEntity: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
-}
-export type TypeOrContainerWithTypes = TypeOrContainerWithTypes_type | TypeOrContainerWithTypes_packageAlias | TypeOrContainerWithTypes_packageNameSegment;
-export declare class TypeOrContainerWithTypes_type implements ITypeOrContainerWithTypes {
-    readonly value: TypeDeclaration;
-    readonly kind = "type";
-    constructor(value: TypeDeclaration);
-    getName(): Name;
-    isHidden(): EntityHidingLevel | undefined;
-}
-export declare class TypeOrContainerWithTypes_packageAlias implements ITypeOrContainerWithTypes {
-    readonly value: PackageAliasEntity;
-    readonly kind = "package-alias";
-    constructor(value: PackageAliasEntity);
-    getName(): Name;
-    isHidden(): EntityHidingLevel | undefined;
-}
-export declare class TypeOrContainerWithTypes_packageNameSegment implements ITypeOrContainerWithTypes {
-    readonly value: PackageNameTreeNode;
-    readonly kind = "package-name-segment";
-    constructor(value: PackageNameTreeNode);
-    getName(): Name;
-    isHidden(): EntityHidingLevel | undefined;
-}
-interface ITypeOrContainerWithTypes {
-    getName(): Name;
-    isHidden(): EntityHidingLevel | undefined;
-}
-export type TypeDeclaration = TypeDeclaration_structured | TypeDeclaration_variant | TypeDeclaration_method | TypeDeclaration_parameter | TypeDeclaration_alias;
-export declare class TypeDeclaration_structured implements ITypeDeclaration {
-    readonly value: PackageStructuredTypeEntity;
-    readonly kind = "structured";
-    constructor(value: PackageStructuredTypeEntity);
-    getArity(): number;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getName(): Name;
-    getEntity(): NamedTypeEntity;
-    isHidden(): EntityHidingLevel | undefined;
-    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
-}
-export declare class TypeDeclaration_variant implements ITypeDeclaration {
-    readonly value: PackageVariantTypeEntity;
-    readonly kind = "variant";
-    constructor(value: PackageVariantTypeEntity);
-    getArity(): number;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getName(): Name;
-    getEntity(): NamedTypeEntity;
-    isHidden(): EntityHidingLevel | undefined;
-    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
-}
-export declare class TypeDeclaration_method implements ITypeDeclaration {
-    readonly value: PackageMethodTypeEntity;
-    readonly kind = "method";
-    constructor(value: PackageMethodTypeEntity);
-    getArity(): number;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getName(): Name;
-    getEntity(): NamedTypeEntity;
-    isHidden(): EntityHidingLevel | undefined;
-    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
-}
-export declare class TypeDeclaration_parameter implements ITypeDeclaration {
-    readonly value: TypeParameterEntity;
-    readonly kind = "parameter";
-    constructor(value: TypeParameterEntity);
-    getArity(): number;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getName(): Name;
-    getEntity(): NamedTypeEntity;
-    isHidden(): EntityHidingLevel | undefined;
-    instantiate(analyzer: Analyzer, _typeArguments: readonly types.Type[]): types.Type;
-}
-export declare class TypeDeclaration_alias implements ITypeDeclaration {
-    readonly value: AliasTypeEntity;
-    readonly kind = "alias";
-    constructor(value: AliasTypeEntity);
-    getArity(): number;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getName(): Name;
-    getEntity(): NamedTypeEntity;
-    isHidden(): EntityHidingLevel | undefined;
-    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
-}
-interface ITypeDeclaration {
-    getArity(): number;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getName(): Name;
-    getEntity(): NamedTypeEntity;
-    isHidden(): EntityHidingLevel | undefined;
-    instantiate(analyzer: Analyzer, typeArguments: readonly types.Type[]): types.Type;
-}
-export type NamedDeclaration = NamedDeclaration_method | NamedDeclaration_variable | NamedDeclaration_type | NamedDeclaration_variant | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
+    getTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<TypeOrContainerWithTypes>[];
+    getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedDeclaration>[];
+    getOperators(hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getTypeExtensionsByType(typeEntity: TypeEntity, hidingMatcher?: IEntityHidingMatcher): readonly TypeExtensionEntity[];
+}
+export type TypeOrContainerWithTypes = NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
+export type NamedDeclaration = NamedDeclaration_method | NamedDeclaration_variable | NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
 export declare class NamedDeclaration_method implements INamedDeclaration {
     readonly value: NamedDeclarationMethod;
     readonly kind = "method";
@@ -193,16 +104,9 @@ interface INamedDeclarationVariable {
     isHidden(): EntityHidingLevel | undefined;
 }
 export declare class NamedDeclaration_type implements INamedDeclaration {
-    readonly value: TypeDeclaration;
+    readonly value: NamedTypeEntity;
     readonly kind = "type";
-    constructor(value: TypeDeclaration);
-    getName(): Name;
-    isHidden(): EntityHidingLevel | undefined;
-}
-export declare class NamedDeclaration_variant implements INamedDeclaration {
-    readonly value: VariantEntity;
-    readonly kind = "variant";
-    constructor(value: VariantEntity);
+    constructor(value: NamedTypeEntity);
     getName(): Name;
     isHidden(): EntityHidingLevel | undefined;
 }
@@ -229,7 +133,9 @@ export declare class SourceFileScope implements IScope {
     private readonly _containingPackageMemberLookup;
     private readonly _importedPackageMemberLookups;
     private readonly _packageNameSegments;
+    private readonly _packageNameSegmentsByKey;
     private readonly _locale;
+    private get packageNameSegmentsByKey();
     constructor(analyzer: Analyzer, node: tree.SourceFile);
     getTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
@@ -238,7 +144,6 @@ export declare class SourceFileScope implements IScope {
     getOperators(_hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
     getOperatorsByKind(_kind: OperatorKind, _hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
-    private convertPackageMembersTypeDeclaration;
     private convertPackageMemberToNamedDeclaration;
     private convertPackageAliasToTypeOrContainerWithTypes;
     private convertPackageMemberToTypeOrContainerWithTypes;
@@ -247,15 +152,15 @@ export declare class SourceFileScope implements IScope {
     private checkNamedDeclarationShadowing;
 }
 export declare class GenericScope implements IScope {
-    private readonly _typeOrContainerWithTypes;
     private readonly _namedDeclarations;
+    private readonly _typeOrContainerWithTypes;
     private readonly _typeExtensionEntities;
     private readonly _locale;
     private readonly _namedDeclarationsByName;
     private readonly _typesOrContainerWithTypesByName;
     private get namedDeclarationsByName();
     private get typesOrContainerWithTypesByName();
-    constructor(typeOrContainerWithTypes: readonly TypeOrContainerWithTypes[], namedDeclarations: readonly NamedDeclaration[], typeExtensionEntities: readonly TypeExtensionEntity[], locale: PackageLocale);
+    constructor(namedDeclarations: readonly NamedDeclaration[], typeExtensionEntities: readonly TypeExtensionEntity[], locale: PackageLocale);
     getTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getTypesOrContainersWithTypesByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
@@ -284,7 +189,7 @@ export declare class ParameterDeclarationsScope implements IScope {
     getTypeExtensionsByType(typeEntity: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
     private checkHiding;
 }
-export declare class StructuredTypeBodyScope implements IScope {
+export declare class TypeWithMembersBodyScope implements IScope {
     private readonly _memberLookup;
     private readonly _typeExtensionsLookup;
     constructor(_memberLookup: TypeMemberLookup, _typeExtensionsLookup: Lookup);
@@ -292,8 +197,8 @@ export declare class StructuredTypeBodyScope implements IScope {
     getTypesOrContainersWithTypesByName(_name: SearchName, _hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<TypeOrContainerWithTypes>[];
     getNamedDeclarations(hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
     getNamedDeclarationsByName(name: SearchName, hidingMatcher: IEntityHidingMatcher | undefined): FoundNamedDeclaration<NamedDeclaration>[];
-    getOperators(hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
+    getOperators(hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(_typeEntity: TypeEntity, _hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
     private convertNamedMember;
 }
@@ -312,7 +217,7 @@ export declare class TypeExtensionBodyScope implements IScope {
     getNamedDeclarations(hidingMatcher: IEntityHidingMatcher | undefined): FoundNamedDeclaration<NamedDeclaration>[];
     getNamedDeclarationsByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): FoundNamedDeclaration<NamedDeclaration>[];
     getOperators(hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher): FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind, hidingMatcher?: IEntityHidingMatcher): readonly FoundAnonymousDeclaration<types.Operator>[];
     getTypeExtensionsByType(_typeEntity: TypeEntity, _hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
     private convertNamedTypeExtensionMember;
     private convertTypeExtensionOperator;

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

@@ -21,7 +21,7 @@ export interface SemanticContext {
     getContainingSourceFile(): SourceFile;
     getContainingPackage(): PackageEntity;
     getLocalizationContext(): LocalizationContext;
-    isInRunStatementWithClauses(): RunStatementClausesInfo | undefined;
+    isInTryStatement(): TryStatementClausesInfo | undefined;
     isInFinallyClause(): boolean;
     getScopeLookup(): Lookup;
     getHidingMatcher(): IEntityHidingMatcher;
@@ -35,6 +35,8 @@ export declare namespace SubprogramInfo {
         constructor(analyzer: Analyzer, node: MethodDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        private getEntity;
     }
     export class Operator implements ISubprogramInfo {
         readonly kind = "operator";
@@ -43,6 +45,7 @@ export declare namespace SubprogramInfo {
         constructor(analyzer: Analyzer, node: tree.OperatorDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
     }
     export class Constructor implements ISubprogramInfo {
         readonly kind = "constructor";
@@ -51,6 +54,7 @@ export declare namespace SubprogramInfo {
         constructor(analyzer: Analyzer, node: tree.TypeConstructorDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
         getEntity(): ConstructorEntity;
     }
     export class Destructor implements ISubprogramInfo {
@@ -60,6 +64,7 @@ export declare namespace SubprogramInfo {
         constructor(analyzer: Analyzer, node: tree.TypeDestructorDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
     }
     export class Getter implements ISubprogramInfo {
         readonly kind = "getter";
@@ -68,6 +73,7 @@ export declare namespace SubprogramInfo {
         constructor(analyzer: Analyzer, node: GetterDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
     }
     export class Setter implements ISubprogramInfo {
         readonly kind = "setter";
@@ -76,6 +82,7 @@ export declare namespace SubprogramInfo {
         constructor(analyzer: Analyzer, node: SetterDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
     }
     export class PackageConstructor implements ISubprogramInfo {
         readonly kind = "package-constructor";
@@ -84,6 +91,7 @@ export declare namespace SubprogramInfo {
         constructor(analyzer: Analyzer, node: tree.PackageConstructorDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
         getPackageEntity(): PackageEntity;
     }
     export class PackageEntryPoint implements ISubprogramInfo {
@@ -93,6 +101,7 @@ export declare namespace SubprogramInfo {
         constructor(analyzer: Analyzer, node: tree.PackageEntryPointDeclaration);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
         getPackageEntity(): PackageEntity;
     }
     export class MethodLiteral implements ISubprogramInfo {
@@ -102,10 +111,13 @@ export declare namespace SubprogramInfo {
         constructor(analyzer: Analyzer, node: RegularOrBlockMethodLiteral);
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
+        private getSignatureType;
     }
     interface ISubprogramInfo {
         getReturnType(): types.Type | undefined;
         isGenerator(): boolean;
+        allowsAsyncCalls(): boolean;
     }
     export {};
 }
@@ -131,10 +143,10 @@ export declare namespace TypeOrTypeExtension {
     }
     export {};
 }
-export declare class RunStatementClausesInfo {
-    readonly hasOnErrorClause: boolean;
+export declare class TryStatementClausesInfo {
+    readonly hasCatchClause: boolean;
     readonly hasFinallyClause: boolean;
-    constructor(hasOnErrorClause: boolean, hasFinallyClause: boolean);
+    constructor(hasCatchClause: boolean, hasFinallyClause: boolean);
 }
 declare abstract class SemanticContextWithParent implements SemanticContext {
     protected readonly _parentContext: SemanticContext;
@@ -145,7 +157,7 @@ declare abstract class SemanticContextWithParent implements SemanticContext {
     getContainingSourceFile(): SourceFile;
     getContainingPackage(): PackageEntity;
     getLocalizationContext(): LocalizationContext;
-    isInRunStatementWithClauses(): RunStatementClausesInfo | undefined;
+    isInTryStatement(): TryStatementClausesInfo | undefined;
     isInFinallyClause(): boolean;
     getScopeLookup(): Lookup;
     getHidingMatcher(): IEntityHidingMatcher;
@@ -161,7 +173,7 @@ export declare class SourceFileSemanticContext implements SemanticContext {
     getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
     getContainingSourceFile(): SourceFile;
     getContainingPackage(): PackageEntity;
-    isInRunStatementWithClauses(): RunStatementClausesInfo | undefined;
+    isInTryStatement(): TryStatementClausesInfo | undefined;
     isInFinallyClause(): boolean;
     getScopeLookup(): Lookup;
     getLocalizationContext(): LocalizationContext;
@@ -178,7 +190,7 @@ export declare class LastSemanticContextOfType extends SemanticContextWithParent
     constructor(analyzer: Analyzer, node: TypeDeclarationCreatingSemanticContext, parentContext: SemanticContext);
     getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
     getContainingSubprogram(): SubprogramInfo | undefined;
-    isInRunStatementWithClauses(): RunStatementClausesInfo | undefined;
+    isInTryStatement(): TryStatementClausesInfo | undefined;
     isInFinallyClause(): boolean;
     private getContainingType;
 }
@@ -217,7 +229,7 @@ export declare class LastSemanticContextOfMethod extends SemanticContextWithPare
     private readonly _subprogramInfo;
     constructor(analyzer: Analyzer, node: MethodDeclaration, parentContext: SemanticContext);
     getContainingSubprogram(): SubprogramInfo | undefined;
-    isInRunStatementWithClauses(): RunStatementClausesInfo | undefined;
+    isInTryStatement(): TryStatementClausesInfo | undefined;
     isInFinallyClause(): boolean;
 }
 export declare class MethodTypeParameterSemanticContext extends SemanticContextWithParent {
@@ -295,10 +307,8 @@ export declare class GetterSemanticContext extends SemanticContextWithParent {
 export declare class SetterSemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;
     private readonly _node;
-    private readonly _scopeChain;
     private readonly _subprogramInfo;
     constructor(analyzer: Analyzer, node: SetterDeclaration, parentContext: SemanticContext);
-    getScopeChain(): ScopeChain;
     getContainingSubprogram(): SubprogramInfo | undefined;
 }
 export declare class StatementBlockSemanticContext extends SemanticContextWithParent {
@@ -307,7 +317,7 @@ export declare class StatementBlockSemanticContext extends SemanticContextWithPa
     private readonly _scopeChain;
     constructor(analyzer: Analyzer, node: tree.StatementBlock, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
-    isInRunStatementWithClauses(): RunStatementClausesInfo | undefined;
+    isInTryStatement(): TryStatementClausesInfo | undefined;
     isInFinallyClause(): boolean;
 }
 export type RegularOrBlockMethodLiteral = tree.MethodLiteral | tree.MethodBlockLiteral;
@@ -327,11 +337,11 @@ export declare class ForStatementSemanticContext extends SemanticContextWithPare
     constructor(analyzer: Analyzer, node: tree.ForStatement, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
 }
-export declare class OnErrorClauseSemanticContext extends SemanticContextWithParent {
+export declare class CatchClauseSemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;
     private readonly _node;
     private readonly _scopeChain;
-    constructor(analyzer: Analyzer, node: tree.OnErrorClause, parentContext: SemanticContext);
+    constructor(analyzer: Analyzer, node: tree.CatchClause, parentContext: SemanticContext);
     getScopeChain(): ScopeChain;
 }
 export {};

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

@@ -38,7 +38,7 @@ export declare class SemanticContextBuilder {
     ofTypeDestructorDeclaration(node: tree.TypeDestructorDeclaration): SemanticContext;
     ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
     ofTypeIndexedSetterDeclaration(node: tree.TypeIndexedSetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
-    ofOnErrorClause(node: tree.OnErrorClause): SemanticContext;
+    ofCatchClause(node: tree.CatchClause): SemanticContext;
     private containingInternal;
     private ofChildOfMethodDeclaration;
     private ofChildOfTypeDeclarationWithMemberBlock;