@artel/artc 0.6.25220 → 0.6.25222

package/build/{chunk-AUDD2JDS.js → chunk-UZK7JCND.js}

@@ -10,7 +10,7 @@ import {
   WellKnownDeclarationsLoadError,
   __async,
   createTsInteropInputsForCompilation
-} from "./chunk-RHY36EE7.js";
+} from "./chunk-ODWG5ZXF.js";
 
 // source/executor/Compiler.ts
 var Compiler = class {
@@ -69,7 +69,7 @@ var Compiler = class {
     return __async(this, null, function* () {
       if (analyzer.compilation.mainPackage === void 0) {
         _diagnostics?.addDiagnostic(new Diagnostic(DiagnosticData.withCode(
-          119 /* ProgramWithoutMainPackageCanNotBeCompiled */
+          127 /* ProgramWithoutMainPackageCanNotBeCompiled */
         ), void 0));
         return void 0;
       }
@@ -83,7 +83,7 @@ var Compiler = class {
     return __async(this, null, function* () {
       if (analyzer.compilation.mainPackage === void 0) {
         _diagnostics?.addDiagnostic(new Diagnostic(DiagnosticData.withCode(
-          119 /* ProgramWithoutMainPackageCanNotBeCompiled */
+          127 /* ProgramWithoutMainPackageCanNotBeCompiled */
         ), void 0));
         return "";
       }

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

@@ -21,6 +21,7 @@ import * as autotypeCallExpressionMeaning from './AutotypeCallExpressionMeaning.
 import * as baseExpressionMeaning from './BaseExpressionMeaning.js';
 import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import * as constructorOverloadResolver from './ConstructorOverloadResolver.js';
+import { ControlFlowGraphBuildResult } from './ControlFlowGraphBuilder.js';
 import { DeclarationsUsageCountResult } from './DeclarationsUsageCounter.js';
 import * as dereferenceExpressionMeaning from './DereferenceExpressionMeaning.js';
 import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
@@ -91,8 +92,9 @@ export declare class Analyzer {
     private readonly _extendedTypes;
     private readonly _analyzedTranslationPackages;
     private readonly _linkedMultiPlatformPackagesByPlatform;
-    private readonly _bodyUsesYieldStatementCheckResults;
+    private readonly _functionBlockWithYieldStatementCheckResults;
     private readonly _namedDeclarationsUsageCountResults;
+    private readonly _controlFlowGraphs;
     get tsInterop(): TsInteropContext;
     constructor(compilation: project.Compilation, tsInteropInputs: TsInteropInputs);
     getProjectSourceFile(node: tree.SourceFile): project.SourceFile;
@@ -105,7 +107,8 @@ export declare class Analyzer {
         referencedType: types.Type;
     } | undefined;
     isTypeAssignableTo(source: types.Type, target: types.Type): boolean;
-    checkStatementBlockInvokesAsyncMethods(node: tree.StatementBlock): boolean;
+    getTypeAssignabilityFlags(source: types.Type, target: types.Type): TypeAssignabilityFlags;
+    checkBlockInvokesAsyncMethods(node: tree.StatementBlock | tree.FunctionBlock): boolean;
     getSyntacticAccessKind(node: tree.Expression): SyntacticAccessKind;
     getTypeMemberEntityContainer(node: tree.TypeMemberDeclaration): e.TypeMemberEntityContainer;
     getTargetTypeOfExpression(node: tree.Expression, hint?: TargetTypeHint): types.Type | undefined;
@@ -128,8 +131,37 @@ export declare class Analyzer {
     resolveTag(node: tree.Tag): tagMeaning.ResolutionResult;
     getObjectExpressionMeaning(node: tree.ObjectExpression): objectExpressionMeaning.Meaning;
     getBaseExpressionMeaning(node: tree.BaseExpression): baseExpressionMeaning.Meaning;
-    checkExpressionOptionalChaining(node: tree.Expression): boolean;
-    makeNoneAssignableToTypeIfExpressionOptionalChaining(type: types.Type, node: tree.Expression): types.Type;
+    /**
+     * Проверяет, является ли выражение цепочкой доступов через `?`, заканчивающейся выражением, тип которого допускает
+     * `пусто`.
+     *
+     * Пример:
+     * ```artel
+     * а?.б
+     * а?[1]
+     * а?^
+     * а?()
+     * (а)?.б
+     * ```
+     *
+     * где тип переменной `а` допускает `пусто`.
+     */
+    isExpressionValidOptionalChaining(node: tree.Expression): boolean;
+    /**
+     * Проверяет, является ли выражение цепочкой доступов через `?`.
+     *
+     * Пример:
+     * ```artel
+     * а?.б
+     * а?[1]
+     * а?^
+     * а?()
+     * (а)?.б
+     * ```
+     */
+    isExpressionOptionalChainingSyntactically(node: tree.Expression): boolean;
+    isExpressionValidOutermostOptionalChaining(node: tree.Expression): boolean;
+    makeNoneAssignableToTypeIfExpressionValidOutermostOptionalChaining(type: types.Type, node: tree.Expression): types.Type;
     checkIdentifierNameIsReserved(name: string, locale: PackageLocale): ReservedIdentifierKind | undefined;
     getReservedIdentifierName(reservedIdentifierKind: ReservedIdentifierKind, locale: PackageLocale): string;
     createNameFromIdentifier(node: tree.Identifier): Name;
@@ -152,7 +184,7 @@ export declare class Analyzer {
     checkExpressionDenotesPackageNameSegment(expression: tree.Expression): {
         packageTreeNode: PackageNameTreeNode;
     } | undefined;
-    checkMethodBodyUsesYieldStatement(node: tree.StatementBlock): boolean;
+    checkFunctionBlockWithYieldStatement(node: tree.FunctionBlock): boolean;
     enumerateAspects(type: types.Type): Iterable<types.StructuredType>;
     checkTypeIsBasedOnAspect(type: types.Type, aspectEntity: e.StructuredTypeEntity): boolean;
     resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
@@ -200,6 +232,7 @@ export declare class Analyzer {
      * - Т: Объект?    -> нет, поскольку в качестве конкретного типа, заменяющего параметр, может быть использован тип, исключающий `пусто`.
      */
     isNoneAssignableToType(type: types.Type): boolean;
+    excludeTypeFromUnion(initialType: types.Type, excludedType: types.Type): types.Type;
     isMethodValueParameterVariadic(entity: e.VariableEntity): boolean;
     getDefaultTypeParameterConstraint(): types.Type;
     getOriginalSignatureTypeOfMethodEntity(entity: e.MethodEntity): types.MethodType;
@@ -217,6 +250,7 @@ export declare class Analyzer {
     createPackageMemberHiding(node: tree.PackageMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
     createTypeMemberHiding(node: tree.TypeMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
     getDeclarationsUsageCount(sourceFile: tree.SourceFile, cancellationToken: CancellationToken | undefined): Promise<DeclarationsUsageCountResult>;
+    isFunctionResultNone(node: tree.FunctionBlock): boolean;
     isExpressionImplicitlyReturnedFromSubprogram(node: tree.ExpressionStatement): boolean;
     createBackingPackageVariables(declaredMembers: readonly (e.NamedPackageMemberEntity | e.PackageAliasEntity)[], pkg: e.PackageEntity): e.PackageVariableEntity[];
     createBackingTypeVariables(declaredMembers: readonly NamedTypeMemberEntity[], type: e.TypeEntity): e.TypeVariableEntity[];
@@ -229,6 +263,7 @@ export declare class Analyzer {
     checkBodyOfRedefinableAliasTypeMethod(node: tree.TypeMethodDeclaration, diagnostics?: DiagnosticAcceptor): {
         redefinableMethodOfOriginalType: e.TypeMethodEntity;
     } | undefined;
+    getControlFlowGraph(sourceFile: project.SourceFile): ControlFlowGraphBuildResult;
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -299,6 +334,7 @@ declare class Type {
     private getTargetlessMethodBlockLiteralType;
     private inferMethodLiteralTypeFromNodeWithFallbackToTargetType;
     private inferMethodLiteralTypeFromNode;
+    private getNarrowedTypeIfNarrowableReference;
 }
 declare class ReturnType {
     private readonly _analyzer;
@@ -426,6 +462,7 @@ declare class Scope {
     private readonly _nestedMethodDeclarationTypeParametersScopes;
     private readonly _nestedMethodDeclarationValueParametersScopes;
     private readonly _methodLiteralScopes;
+    private readonly _functionBlockScopes;
     private readonly _statementBlockScopes;
     private readonly _forEachStatementScopes;
     private readonly _catchClauseScopes;
@@ -452,6 +489,7 @@ declare class Scope {
     ofNestedMethodDeclarationTypeParameters(node: tree.NestedMethodDeclaration): scope.IScope;
     ofNestedMethodDeclarationValueParameters(node: tree.NestedMethodDeclaration): scope.IScope;
     ofMethodLiteral(node: tree.MethodLiteral): scope.IScope;
+    ofFunctionBlock(node: tree.FunctionBlock): scope.IScope;
     ofStatementBlock(node: tree.StatementBlock): scope.IScope;
     ofForStatement(node: tree.ForStatement): scope.IScope;
     ofCatchClause(node: tree.CatchClause): scope.IScope;
@@ -569,11 +607,20 @@ declare class OwningPlainObjectModificationCheck {
     private _analyzer;
     private readonly _owningPlainObjectModificationCheckResult;
     constructor(_analyzer: Analyzer);
-    ofDeclarationBody(node: tree.StatementBlock): boolean;
+    ofDeclarationBody(node: tree.FunctionBlock): boolean;
     private checkMethodBodyModifiesPlainObject;
     private checkReceiverModifiesPlainObjectRecursively;
     private nodeBelongsToPlainObjectDeclaration;
 }
+export declare enum TypeAssignabilityFlags {
+    NotAssignable = 1,
+    Identity = 2,
+    DerivedToBase = 4,
+    MethodTypes = 8,
+    ImplicitConversion = 16,
+    First = 1,
+    Last = 16
+}
 declare class PackageImports {
     private readonly _analyzer;
     private readonly _packagesAvailableForImport;

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

@@ -0,0 +1,121 @@
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { SourceFile } from '../project/SourceFile.js';
+import * as tree from '../tree/index.js';
+export declare class ControlFlowGraphBuilder {
+    private readonly _sourceFile;
+    private readonly _controlFlowNodeByReference;
+    private readonly _unreachableCodeDiagnostics;
+    private _isInRebuildingFinallyClauseGraphMode;
+    private _currentPredecessor;
+    private _currentContinueLoopTarget;
+    private _currentBreakLoopTarget;
+    private _currentErrorTarget;
+    private _currentReturnTarget;
+    constructor(sourceFile: SourceFile);
+    build(): ControlFlowGraphBuildResult;
+    private visitNode;
+    private visitAssignmentStatement;
+    private visitIfStatement;
+    private visitWhileStatement;
+    private visitLoopStatement;
+    private visitForStatement;
+    private visitContinueLoopStatement;
+    private visitBreakLoopStatement;
+    private visitSwitchStatement;
+    private visitTryStatement;
+    private visitReturnStatement;
+    private visitErrorStatement;
+    private visitLocalVariableDeclaration;
+    private visitWhenTernaryExpression;
+    private visitCondition;
+    private visitBinaryExpression;
+    private visitPrefixUnaryExpressionInCondition;
+    private visitIsExpressionInCondition;
+    private setAssignmentAsCurrentPredecessor;
+    private visitChildren;
+    private addUnreachableCodeDiagnostic;
+}
+export declare class ControlFlowGraphBuildResult {
+    readonly controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, ControlFlowNode>;
+    readonly unreachableCodeDiagnostics: readonly Diagnostic[];
+    constructor(controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, ControlFlowNode>, unreachableCodeDiagnostics: readonly Diagnostic[]);
+}
+export type NarrowableExpression = tree.IdentifierExpression | tree.PropertyAccessExpression | tree.ObjectExpression;
+export declare function isNarrowableExpression(node: tree.Node): node is tree.Expression;
+export type NarrowableReferenceExpression = tree.IdentifierExpression | tree.PropertyAccessExpression | tree.ObjectExpression;
+export declare function isNarrowableReferenceExpression(node: tree.Node): node is NarrowableReferenceExpression;
+export type ControlFlowNode = ControlFlowNode.Start | ControlFlowNode.Condition | ControlFlowNode.Assignment | ControlFlowNode.Split | ControlFlowNode.Loop | ControlFlowNode.Unreachable;
+export declare namespace ControlFlowNode {
+    abstract class ControlFlowNodeBase {
+        protected abstract thisAsNode: ControlFlowNode;
+        /**
+         * Для отладочных целей.
+         */
+        generateVisualizationCode(): string;
+    }
+    /**
+     * Начальный узел, не имеющий предшественников.
+     */
+    export class Start extends ControlFlowNodeBase {
+        readonly kind = "start";
+        get debuggerDisplay(): string;
+        protected get thisAsNode(): ControlFlowNode;
+    }
+    /**
+     * Хранит информацию об истинности некоторого условия. Например, если условие `а != пусто` истинно, то из типа
+     * переменной `а` необходимо исключить тип `Пусто`.
+     */
+    export class Condition extends ControlFlowNodeBase {
+        readonly predecessor: ControlFlowNode;
+        readonly syntaxNode: ConditionControlFlowNodeExpression;
+        readonly isTrue: boolean;
+        readonly kind = "condition";
+        get debuggerDisplay(): string;
+        protected get thisAsNode(): ControlFlowNode;
+        constructor(predecessor: ControlFlowNode, syntaxNode: ConditionControlFlowNodeExpression, isTrue: boolean);
+    }
+    /**
+     * Создаётся в местах присваивания значений в переменную, а также объявления переменных с начальным значением.
+     * После присваивания тип переменной меняется на тип выражения справа от равно.
+     */
+    export class Assignment extends ControlFlowNodeBase {
+        readonly predecessor: ControlFlowNode;
+        readonly syntaxNode: tree.AssignmentStatement | tree.LocalVariableDeclaration;
+        readonly kind = "assignment";
+        get debuggerDisplay(): string;
+        protected get thisAsNode(): ControlFlowNode;
+        constructor(predecessor: ControlFlowNode, syntaxNode: tree.AssignmentStatement | tree.LocalVariableDeclaration);
+    }
+    /**
+     * Вспомогательный узел, использующийся в местах, где происходит разветвление графа потока управления. Тип переменной
+     * для этого узла определяется как союзный тип из типов переменных в предшествующих узлах.
+     */
+    export class Split extends ControlFlowNodeBase {
+        readonly predecessors: readonly ControlFlowNode[];
+        readonly kind = "split";
+        get debuggerDisplay(): string;
+        protected get thisAsNode(): ControlFlowNode;
+        constructor(predecessors: readonly ControlFlowNode[]);
+    }
+    /**
+     * Используется для циклов (пока, цикл - повтор пока, для-из). Отличается от узла `Split` тем, что предшествующие
+     * узлы, указанные в массиве `loopingPredecessors` образуют циклы в графе потока управления.
+     */
+    export abstract class Loop extends ControlFlowNodeBase {
+        readonly kind = "loop";
+        get debuggerDisplay(): string;
+        protected get thisAsNode(): ControlFlowNode;
+        abstract predecessor: ControlFlowNode;
+        abstract loopingPredecessors: readonly ControlFlowNode[];
+    }
+    /**
+     * Обозначает недостижимый код.
+     */
+    export class Unreachable extends ControlFlowNodeBase {
+        readonly kind = "unreachable";
+        get debuggerDisplay(): string;
+        protected get thisAsNode(): ControlFlowNode;
+    }
+    export {};
+}
+export type ConditionControlFlowNodeExpression = tree.BinaryExpression | tree.IsExpression;

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

@@ -0,0 +1,12 @@
+import { ControlFlowNode } from './ControlFlowGraphBuilder.js';
+export declare class ControlFlowGraphVisualizer {
+    /**
+     * Создаёт описание графа на языке Dot.
+     *
+     * Визуализацию графа можно посмотреть по этой ссылке:
+     * https://dreampuf.github.io/GraphvizOnline/?engine=dot#digraph%20%7B%20%7D
+     */
+    static generateGraphDescriptionInDotLanguage(startNode: ControlFlowNode): string;
+    private static getLabel;
+    private static createGetIdFunction;
+}

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 checkDereferenceExpression;
+    private checkIndexedAccessExpression;
     private checkCallExpression;
     private addNotTranslatedPackageMembersDiagnostics;
     private collectNotTranslatedPackageMembers;
@@ -60,6 +62,7 @@ export declare class DiagnosticCollector {
     private checkAssignmentToObjectExpression;
     private checkAssignmentToDereferenceExpression;
     private checkAssignmentToIndexedAccessExpression;
+    private checkOptionalChainingIsUsedOnTheLeftSideOfAssignment;
     private checkGenericSpecializationExpression;
     private checkMethodSpecialization;
     private checkTypeSpecialization;

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

@@ -11,11 +11,13 @@ export declare class NodeTypeUtils {
     static isTypeSpecifier(node: tree.Node): node is tree.TypeSpecifier;
     static isMethodDeclaration(node: tree.Node): node is MethodDeclaration;
     static isVariableDeclaration(node: tree.Node): node is VariableDeclaration;
+    static isVariantTypeDeclaration(node: tree.Node): node is VariantTypeDeclaration;
+    static isSubprogramDeclaration(node: tree.Node): node is SubprogramDeclaration;
+    static isNoneLiteral(node: tree.Node): boolean;
 }
 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;
@@ -27,3 +29,4 @@ export type PackageVariableAccessorDeclaration = tree.PackageVariableGetterDecla
 export type TypeVariableAccessorDeclaration = tree.TypeVariableGetterDeclaration | tree.TypeVariableSetterDeclaration;
 export type TypeIndexedAccessorDeclaration = tree.TypeIndexedGetterDeclaration | tree.TypeIndexedSetterDeclaration;
 export type TypeDereferencedVariableAccessorDeclaration = tree.TypeDereferencedVariableGetterDeclaration | tree.TypeDereferencedVariableSetterDeclaration;
+export type SubprogramDeclaration = tree.FunctionBlockParent | tree.MethodLiteral | tree.MethodBlockLiteral;

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

@@ -320,6 +320,13 @@ export declare class StatementBlockSemanticContext extends SemanticContextWithPa
     isInTryStatement(): TryStatementClausesInfo | undefined;
     isInFinallyClause(): boolean;
 }
+export declare class FunctionBlockSemanticContext extends SemanticContextWithParent {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _scopeChain;
+    constructor(analyzer: Analyzer, node: tree.FunctionBlock, parentContext: SemanticContext);
+    getScopeChain(): ScopeChain;
+}
 export type RegularOrBlockMethodLiteral = tree.MethodLiteral | tree.MethodBlockLiteral;
 export declare class MethodLiteralSemanticContext extends SemanticContextWithParent {
     private readonly _analyzer;

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

@@ -34,6 +34,7 @@ export declare class SemanticContextBuilder {
     ofRegularOrBlockMethodLiteral(node: RegularOrBlockMethodLiteral): SemanticContext;
     ofForStatement(node: tree.ForStatement): SemanticContext;
     ofStatementBlock(node: tree.StatementBlock): SemanticContext;
+    ofFunctionBlock(node: tree.FunctionBlock): SemanticContext;
     ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): SemanticContext;
     ofTypeDestructorDeclaration(node: tree.TypeDestructorDeclaration): SemanticContext;
     ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
@@ -53,4 +54,5 @@ export declare class SemanticContextBuilder {
     private ofChildOfTypeExtensionDeclaration;
     private isOffsetBetweenNodes;
     private isOffsetInsideStatementBlock;
+    private isOffsetInsideFunctionBlock;
 }

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

@@ -2,22 +2,24 @@ import * as tree from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
 import { IScope } from './Scope.js';
 export declare class StatementBlockScopeBuilder {
-    static build(analyzer: Analyzer, node: tree.StatementBlock): IScope;
-    static buildGenericScope(analyzer: Analyzer, node: tree.StatementBlock): IScope;
-    static buildScopeForMethodBlockLiteral(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.MethodBlockLiteral): IScope;
-    static buildScopeForPackageMethodDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.PackageMethodDeclaration): IScope;
-    static buildScopeForTypeVariableGetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeVariableGetterDeclaration): IScope;
-    static buildScopeForTypeVariableSetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeVariableSetterDeclaration): IScope;
-    static buildScopeForPackageVariableGetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.PackageVariableGetterDeclaration): IScope;
-    static buildScopeForPackageVariableSetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.PackageVariableSetterDeclaration): IScope;
-    static buildScopeForTypeIndexedGetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeIndexedGetterDeclaration): IScope;
-    static buildScopeForTypeIndexedSetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeIndexedSetterDeclaration): IScope;
-    static buildScopeForTypeDereferencedVariableGetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeDereferencedVariableGetterDeclaration): IScope;
-    static buildScopeForTypeDereferencedVariableSetterDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeDereferencedVariableSetterDeclaration): IScope;
-    static buildScopeForNestedMethodDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.NestedMethodDeclaration): IScope;
-    static buildScopeForMethodLiteral(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.MethodLiteral): IScope;
-    static buildScopeForTypeConstructorDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeConstructorDeclaration): IScope;
-    static buildScopeForTypeMethodDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.TypeMethodDeclaration): IScope;
-    static buildScopeForOperatorDeclaration(analyzer: Analyzer, node: tree.StatementBlock, parent: tree.OperatorDeclaration): IScope;
+    static buildFunctionBlockScope(analyzer: Analyzer, node: tree.FunctionBlock): IScope;
+    static buildStatementBlockScope(analyzer: Analyzer, node: tree.StatementBlock): IScope;
+    static buildGenericScopeForFunctionBlock(analyzer: Analyzer, node: tree.FunctionBlock): IScope;
+    static buildGenericScopeForStatementBlock(analyzer: Analyzer, node: tree.StatementBlock): IScope;
+    static buildScopeForMethodBlockLiteral(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.MethodBlockLiteral): IScope;
+    static buildScopeForPackageMethodDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.PackageMethodDeclaration): IScope;
+    static buildScopeForTypeVariableGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeVariableGetterDeclaration): IScope;
+    static buildScopeForTypeVariableSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeVariableSetterDeclaration): IScope;
+    static buildScopeForPackageVariableGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.PackageVariableGetterDeclaration): IScope;
+    static buildScopeForPackageVariableSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.PackageVariableSetterDeclaration): IScope;
+    static buildScopeForTypeIndexedGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeIndexedGetterDeclaration): IScope;
+    static buildScopeForTypeIndexedSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeIndexedSetterDeclaration): IScope;
+    static buildScopeForTypeDereferencedVariableGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeDereferencedVariableGetterDeclaration): IScope;
+    static buildScopeForTypeDereferencedVariableSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeDereferencedVariableSetterDeclaration): IScope;
+    static buildScopeForNestedMethodDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.NestedMethodDeclaration): IScope;
+    static buildScopeForMethodLiteral(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.MethodLiteral): IScope;
+    static buildScopeForTypeConstructorDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeConstructorDeclaration): IScope;
+    static buildScopeForTypeMethodDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeMethodDeclaration): IScope;
+    static buildScopeForOperatorDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.OperatorDeclaration): IScope;
     private static getLocalNamedDeclarations;
 }

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

@@ -0,0 +1,62 @@
+import { LocalVariableEntity, ParameterVariableEntity } from '../entities/VariableEntity.js';
+import * as types from '../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import { ControlFlowNode, NarrowableReferenceExpression } from './ControlFlowGraphBuilder.js';
+export declare class TypeNarrower {
+    private readonly _analyzer;
+    private readonly _referenceExpression;
+    private readonly _initialType;
+    private readonly _controlFlowNode;
+    private _reference;
+    private readonly _typeByNode;
+    constructor(analyzer: Analyzer, referenceExpression: NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: ControlFlowNode);
+    getType(): types.Type;
+    private getTypeAtControlFlowNode;
+    private getTypeAtCondition;
+    private getTypeAtAssignment;
+    private getTypeAtSplit;
+    private getTypeAtLoop;
+    private getTypeAtComparisonWithNone;
+    private getTypeAtIsExpression;
+    private addTypeIfUnique;
+    private isSameReferenceAsNarrowedExpression;
+    private unwrapExpression;
+    private getReferenceAtNodeIfNarrowable;
+    private getReferenceAtNode;
+    private getReferenceAtLocalVariableDeclaration;
+}
+export type NarrowableReference = NarrowableReference.LocalVariable | NarrowableReference.InstanceTypeVariable | NarrowableReference.StaticTypeVariable | NarrowableReference.Object;
+export declare namespace NarrowableReference {
+    export class LocalVariable implements INarrowableReference {
+        readonly entity: LocalVariableEntity | ParameterVariableEntity;
+        readonly kind = "local-variable";
+        constructor(entity: LocalVariableEntity | ParameterVariableEntity);
+        equals(other: NarrowableReference): boolean;
+        contains(_other: NarrowableReference): boolean;
+    }
+    export class InstanceTypeVariable implements INarrowableReference {
+        readonly variable: types.Variable;
+        readonly receiver: NarrowableReference;
+        readonly kind = "instance-type-variable";
+        constructor(variable: types.Variable, receiver: NarrowableReference);
+        equals(other: NarrowableReference): boolean;
+        contains(other: NarrowableReference): boolean;
+    }
+    export class StaticTypeVariable implements INarrowableReference {
+        readonly variable: types.Variable;
+        readonly kind = "static-type-variable";
+        constructor(variable: types.Variable);
+        equals(other: NarrowableReference): boolean;
+        contains(_other: NarrowableReference): boolean;
+    }
+    export class Object implements INarrowableReference {
+        readonly kind = "object";
+        equals(other: NarrowableReference): boolean;
+        contains(_other: NarrowableReference): boolean;
+    }
+    interface INarrowableReference {
+        equals(other: NarrowableReference): boolean;
+        contains(other: NarrowableReference): boolean;
+    }
+    export {};
+}

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

@@ -5,6 +5,7 @@ export declare class Range {
     get isEmpty(): boolean;
     constructor(start: number, end: number);
     includes(offset: number): boolean;
+    includes(range: Range): boolean;
     equals(other: Range): boolean;
     static empty(start: number): Range;
 }