@artel/artc 0.6.26021 → 0.6.26022

package/build/Cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   CommandLineCompiler
-} from "./chunk-BUGHCVWW.js";
-import "./chunk-NKLHVPAI.js";
+} from "./chunk-WXKN3LZG.js";
+import "./chunk-PCY52KYM.js";
 import {
   __async
-} from "./chunk-DWHH53A7.js";
+} from "./chunk-KCEJTV3Q.js";
 
 // source/Cli.ts
 function main() {

package/build/api/Api.js

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "../chunk-NKLHVPAI.js";
+} from "../chunk-PCY52KYM.js";
 import {
   AccessKind,
   AccessedFunction_entity,
@@ -281,7 +281,7 @@ import {
   withoutQuotes,
   withoutTemplateQuotes,
   yieldTask
-} from "../chunk-DWHH53A7.js";
+} from "../chunk-KCEJTV3Q.js";
 export {
   AccessKind,
   AccessedFunction_entity,

package/build/api/ApiNodeJS.js

@@ -6,9 +6,9 @@ import {
   PhysicalFileSystem,
   PhysicalTypeScriptLibrariesProvider,
   PrintingDiagnosticAcceptor
-} from "../chunk-BUGHCVWW.js";
-import "../chunk-NKLHVPAI.js";
-import "../chunk-DWHH53A7.js";
+} from "../chunk-WXKN3LZG.js";
+import "../chunk-PCY52KYM.js";
+import "../chunk-KCEJTV3Q.js";
 export {
   CommandLineCompiler,
   FileSystemUri,

package/build/api/ApiServices.js

@@ -110,7 +110,7 @@ import {
   sortModifiers,
   traverseTreeAsync,
   yieldTask
-} from "../chunk-DWHH53A7.js";
+} from "../chunk-KCEJTV3Q.js";
 
 // source/services/CustomRequests.ts
 import * as ls from "vscode-languageserver";
@@ -10848,12 +10848,10 @@ var EntityFinder = class {
       }
     } else if (entity.subkind === "parameter") {
       const originalContainingEntity = entity.getContainingEntity();
-      if (originalContainingEntity.kind !== 12 /* Package */) {
-        const index = originalContainingEntity.getParameters().indexOf(entity);
-        const containingEntity = this.findEntity(originalContainingEntity);
-        if (containingEntity !== void 0 && index >= 0) {
-          return this.ifEntityWithParametersThenParameters(containingEntity)?.[index];
-        }
+      const index = originalContainingEntity.getParameters().indexOf(entity);
+      const containingEntity = this.findEntity(originalContainingEntity);
+      if (containingEntity !== void 0 && index >= 0) {
+        return this.ifEntityWithParametersThenParameters(containingEntity)?.[index];
       }
     }
     return void 0;

package/build/{chunk-DWHH53A7.js → chunk-KCEJTV3Q.js}

@@ -764,7 +764,7 @@ var UniqueWithComparatorQuery = class extends Query {
 };
 
 // source/common/Constants.ts
-var ArtelVersion = true ? "0.6.26021" : "";
+var ArtelVersion = true ? "0.6.26022" : "";
 var ArtelSourceFileExtensions = [".\u0430\u0440\u0442", ".\u0430\u0440\u0442\u0435\u043B\u044C", ".art", ".artel", ".\u0430\u0440\u0442\u043C", ".\u0430\u0440\u0442\u0435\u043B\u044C\u043C", ".artm", ".artelm"];
 var ArtelSourceFileExtensionSet = new Set(ArtelSourceFileExtensions);
 var ArtelSourceAndConfigurationFileExtensionSet = new Set(ArtelSourceFileExtensionSet).add(".json");
@@ -4482,7 +4482,7 @@ function isEntityWithTypeParameters(entity) {
   return false;
 }
 function isEntityWithParameters(entity) {
-  if (entity.kind === 1 /* Function */ || entity.kind === 2 /* Type */ && entity.typeEntityKind === 0 /* Function */ || entity.kind === 7 /* Constructor */ || entity.kind === 8 /* Destructor */ || entity.kind === 5 /* Indexer */) {
+  if (entity.kind === 1 /* Function */ || entity.kind === 2 /* Type */ && entity.typeEntityKind === 0 /* Function */ || entity.kind === 7 /* Constructor */ || entity.kind === 8 /* Destructor */ || entity.kind === 5 /* Indexer */ || entity.kind === 13 /* TextTranslation */) {
     return true;
   }
   Debug.typeIsAssignableTo();
@@ -12437,6 +12437,7 @@ var DiagnosticCode = /* @__PURE__ */ ((DiagnosticCode2) => {
   DiagnosticCode2[DiagnosticCode2["OperatorCannotBeAsync"] = 2228] = "OperatorCannotBeAsync";
   DiagnosticCode2[DiagnosticCode2["OperatorCannotContainTypeParameterDeclarations"] = 2229] = "OperatorCannotContainTypeParameterDeclarations";
   DiagnosticCode2[DiagnosticCode2["TypeNameExpectedAtLastQualifier"] = 2230] = "TypeNameExpectedAtLastQualifier";
+  DiagnosticCode2[DiagnosticCode2["ExpressionsWithTypes0And1CannotBeCompared"] = 2231] = "ExpressionsWithTypes0And1CannotBeCompared";
   DiagnosticCode2[DiagnosticCode2["CannotFindTsLibDirectoryBaseSearchPaths0"] = 3e3] = "CannotFindTsLibDirectoryBaseSearchPaths0";
   DiagnosticCode2[DiagnosticCode2["SourceFile0IsNotPartOfThePackageAndWontBeLoaded"] = 3001] = "SourceFile0IsNotPartOfThePackageAndWontBeLoaded";
   DiagnosticCode2[DiagnosticCode2["ProgramWithoutMainPackageCannotBeCompiled"] = 3002] = "ProgramWithoutMainPackageCannotBeCompiled";
@@ -12771,6 +12772,7 @@ var englishErrorMessages = {
   [2228 /* OperatorCannotBeAsync */]: "Operator cannot be async.",
   [2229 /* OperatorCannotContainTypeParameterDeclarations */]: "Operator cannot contain type parameter declarations.",
   [2230 /* TypeNameExpectedAtLastQualifier */]: "Type name expected.",
+  [2231 /* ExpressionsWithTypes0And1CannotBeCompared */]: "Expressions with types '{0}' and '{1}' cannot be compared.",
   [3e3 /* CannotFindTsLibDirectoryBaseSearchPaths0 */]: "Can not find directory with TypeScript library. Base search paths: {0}.",
   [3001 /* SourceFile0IsNotPartOfThePackageAndWontBeLoaded */]: "Source file '{0}' is not part of the package and won't be loaded.",
   [3002 /* ProgramWithoutMainPackageCannotBeCompiled */]: "Program without main package cannot be compiled.",
@@ -13059,6 +13061,7 @@ var russianErrorMessages = {
   [2228 /* OperatorCannotBeAsync */]: "\u0424\u0443\u043D\u043A\u0446\u0438\u044F \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0438 \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u0430\u0441\u0438\u043D\u0445\u0440\u043E\u043D\u043D\u043E\u0439.",
   [2229 /* OperatorCannotContainTypeParameterDeclarations */]: "\u0424\u0443\u043D\u043A\u0446\u0438\u044F \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0438 \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C \u043E\u0431\u044A\u044F\u0432\u043B\u0435\u043D\u0438\u044F \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u043E\u0432 \u0442\u0438\u043F\u0430.",
   [2230 /* TypeNameExpectedAtLastQualifier */]: "\u041E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C \u0438\u043C\u044F \u0442\u0438\u043F\u0430.",
+  [2231 /* ExpressionsWithTypes0And1CannotBeCompared */]: "\u041D\u0435\u043B\u044C\u0437\u044F \u0441\u0440\u0430\u0432\u043D\u0438\u0442\u044C \u0432\u044B\u0440\u0430\u0436\u0435\u043D\u0438\u044F \u0441 \u0442\u0438\u043F\u0430\u043C\u0438 '{0}' \u0438 '{1}'.",
   [3e3 /* CannotFindTsLibDirectoryBaseSearchPaths0 */]: "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043D\u0430\u0439\u0442\u0438 \u043F\u0430\u043F\u043A\u0443 \u0441\u043E \u0441\u0442\u0430\u043D\u0434\u0430\u0440\u0442\u043D\u043E\u0439 \u0431\u0438\u0431\u043B\u0438\u043E\u0442\u0435\u043A\u043E\u0439 TypeScript. \u041F\u0443\u0442\u0438, \u043E\u0442\u043D\u043E\u0441\u0438\u0442\u0435\u043B\u044C\u043D\u043E \u043A\u043E\u0442\u043E\u0440\u044B\u0445 \u043E\u0441\u0443\u0449\u0435\u0441\u0442\u0432\u043B\u044F\u043B\u0441\u044F \u043F\u043E\u0438\u0441\u043A: {0}.",
   [3001 /* SourceFile0IsNotPartOfThePackageAndWontBeLoaded */]: "\u0418\u0441\u0445\u043E\u0434\u043D\u044B\u0439 \u0444\u0430\u0439\u043B '{0}' \u043D\u0435 \u044F\u0432\u043B\u044F\u0435\u0442\u0441\u044F \u0447\u0430\u0441\u0442\u044C\u044E \u043F\u0430\u043A\u0435\u0442\u0430 \u0438 \u043D\u0435 \u0431\u0443\u0434\u0435\u0442 \u0437\u0430\u0433\u0440\u0443\u0436\u0435\u043D.",
   [3002 /* ProgramWithoutMainPackageCannotBeCompiled */]: "\u041F\u0440\u043E\u0433\u0440\u0430\u043C\u043C\u0430 \u0431\u0435\u0437 \u0433\u043B\u0430\u0432\u043D\u043E\u0433\u043E \u043F\u0430\u043A\u0435\u0442\u0430 \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u0441\u043A\u043E\u043C\u043F\u0438\u043B\u0438\u0440\u043E\u0432\u0430\u043D\u0430.",
@@ -18917,7 +18920,7 @@ var DisplayServiceA = class extends BaseDisplayService {
     const asyncKeyword = func.isAsync() ? `${this.displayKeyword(44 /* Async */)} ` : "";
     const keyword = this.displayKeyword(16 /* Function */);
     const operatorKind = func.getOperatorKind();
-    const name = operatorKind === void 0 ? this.common.displayEntityName(func.getEntity()) : this.displayOperatorKind(operatorKind);
+    const name = operatorKind === void 0 ? this.common.displayEntityName(func.getEntity()) : `'${this.displayOperatorKind(operatorKind)}'`;
     const typeParameters = func.getTypeParameterValues().map((t) => this.displayTypeParameterValue(t));
     const typeParametersStart = typeParameters.length > 0 ? "<" : "";
     const typeParametersEnd = typeParameters.length > 0 ? ">" : "";
@@ -21500,8 +21503,9 @@ var EntityLocalizationContext = class {
         const localizedDestructor = this.getLocalizedDestructorEntity(containingEntity);
         return localizedDestructor.getParameters().find((p) => p.getOriginalEntity() === entity) ?? entity;
       }
-      case 12 /* Package */:
+      case 13 /* TextTranslation */: {
         return entity;
+      }
       default:
         Debug.never(containingEntity);
     }
@@ -50889,7 +50893,7 @@ var FunctionBlockLiteralEntity = class {
     return targetType?.getParameters().map((p) => new IntrinsicParameterEntity(
       p.getEntity().getName(),
       p.getType(),
-      this.getContainingPackage(),
+      this,
       p.isOptional(),
       p.isVariadic(),
       p.isObjectParameter(),
@@ -54128,7 +54132,7 @@ var TranslationTextTemplateParameterEntity = class {
     this.name = analyzer.createNameFromIdentifier(node.name);
   }
   getContainingEntity() {
-    return TreeQuery.getPackageEntity(this.node, this.analyzer);
+    return this.analyzer.entity.ofTextTranslationDeclaration(this.node.parent.parent.parent);
   }
   getName() {
     return this.name;
@@ -58510,10 +58514,7 @@ var SourceFileAnalyzer = class {
         break;
       }
       case 61 /* BinaryExpression */: {
-        const classificationResult = this.analyzer.classifyBinaryExpressionOperator(node.operator);
-        if (classificationResult.kind === "user-definable") {
-          this.analyzer.resolveBinaryExpressionUserDefinableOperator(node, classificationResult.operatorKind);
-        }
+        this.checkBinaryExpression(node);
         break;
       }
       case 90 /* AssignmentStatement */: {
@@ -58763,6 +58764,34 @@ var SourceFileAnalyzer = class {
     }
     return void 0;
   }
+  checkBinaryExpression(node) {
+    const classificationResult = this.analyzer.classifyBinaryExpressionOperator(node.operator);
+    switch (classificationResult.kind) {
+      case "user-definable":
+        this.analyzer.resolveBinaryExpressionUserDefinableOperator(node, classificationResult.operatorKind);
+        break;
+      case "equals":
+      case "not-equals": {
+        const leftType = this.analyzer.type.ofExpression(node.left);
+        const rightType = this.analyzer.type.ofExpression(node.right);
+        if (!this.analyzer.typeUtils.areTypesComparable(leftType, rightType)) {
+          this.createAndAddDiagnostic(
+            2231 /* ExpressionsWithTypes0And1CannotBeCompared */,
+            node.operator,
+            [
+              this.diagnosticArgumentFactory.createDisplayableType(leftType),
+              this.diagnosticArgumentFactory.createDisplayableType(rightType)
+            ]
+          );
+        }
+        break;
+      }
+      case "question-question":
+        break;
+      default:
+        Debug.never(classificationResult);
+    }
+  }
   checkPackageVariantDeclaration(node) {
     if (node.typeParameterClause !== void 0) {
       this.analyzer.semanticContext.ofTypeDeclarationTypeParameters(node, node.typeParameterClause).validateNameConflicts(this.diagnosticAcceptor);
@@ -61754,6 +61783,9 @@ var Analyzer = class {
   get typeAssignabilityCheck() {
     return this.state.typeAssignabilityCheck;
   }
+  get typeComparabilityCheck() {
+    return this.state.typeComparabilityCheck;
+  }
   get overriddenMember() {
     return this.state.overriddenMember;
   }
@@ -61855,6 +61887,9 @@ var Analyzer = class {
   getTypeAssignabilityFlags(source, target) {
     return this.typeAssignabilityCheck.getAssignabilityFlags(source, target);
   }
+  isTypeComparableTo(source, target) {
+    return this.typeComparabilityCheck.isTypeComparableTo(source, target);
+  }
   getUnambiguousTargetFunctionType(targetType) {
     if (targetType !== void 0) {
       const unaliasedType = targetType.unalias();
@@ -62915,6 +62950,7 @@ var CommonAnalyzerState = class {
   initialize(analyzer) {
     this.typeFactory = new TypeFactory(analyzer);
     this.typeAssignabilityCheck = new TypeAssignabilityCheck(analyzer);
+    this.typeComparabilityCheck = new TypeComparabilityCheck(analyzer);
     this.implementation = new ImplementationEntity(analyzer);
     this.typeUtils = new TypeUtils2(analyzer);
     this.signatureComparer = new SignatureComparer(analyzer);
@@ -63996,6 +64032,98 @@ var TypeAssignabilityCheck = class {
     return result;
   }
 };
+var TypeComparabilityCheck = class {
+  constructor(analyzer) {
+    this.analyzer = analyzer;
+  }
+  isTypeComparableTo(source, target) {
+    source = source.unaliasAndGetReductionSource();
+    target = target.unaliasAndGetReductionSource();
+    if (source.kind === "unresolved" || target.kind === "unresolved") {
+      return true;
+    }
+    if (source.isNullType) {
+      return this.analyzer.canTypeBeNull(target);
+    } else if (target.isNullType) {
+      return this.analyzer.canTypeBeNull(source);
+    }
+    source = this.analyzer.excludeNullFromType(source).unaliasAndGetReductionSource();
+    target = this.analyzer.excludeNullFromType(target).unaliasAndGetReductionSource();
+    const objectType = this.analyzer.originalStandardTypes.object;
+    if (source.equals(objectType) || target.equals(objectType)) {
+      return true;
+    }
+    if (source.equals(target)) {
+      return true;
+    }
+    if (source.kind === "parameter" && target.kind === "parameter") {
+      const sourceConstraint = source.constraint;
+      const targetConstraint = target.constraint;
+      if (sourceConstraint !== void 0 && targetConstraint !== void 0) {
+        const result = this.isTypeComparableTo(sourceConstraint, targetConstraint);
+        if (result) {
+          return true;
+        }
+      }
+      return source.getEntity().getOriginalEntity() === target.getEntity().getOriginalEntity();
+    } else if (source.kind === "parameter") {
+      const sourceConstraint = source.constraint;
+      if (sourceConstraint !== void 0) {
+        const result = this.isTypeComparableTo(sourceConstraint, target);
+        if (result) {
+          return true;
+        }
+      }
+    } else if (target.kind === "parameter") {
+      const targetConstraint = target.constraint;
+      if (targetConstraint !== void 0) {
+        const result = this.isTypeComparableTo(source, targetConstraint);
+        if (result) {
+          return true;
+        }
+      }
+    }
+    if (source.kind === "union") {
+      const sourceConstituentTypes = source.unaliasedFlattenedTypes;
+      return sourceConstituentTypes.some((s) => this.isTypeComparableTo(s, target));
+    }
+    if (target.kind === "union") {
+      const targetConstituentTypes = target.unaliasedFlattenedTypes;
+      return targetConstituentTypes.some((t) => this.isTypeComparableTo(source, t));
+    }
+    if (source.kind === "intersection") {
+      const sourceConstituentTypes = source.unaliasedFlattenedTypes;
+      return sourceConstituentTypes.some((s) => this.isTypeComparableTo(s, target));
+    }
+    if (target.kind === "intersection") {
+      const targetConstituentTypes = target.unaliasedFlattenedTypes;
+      return targetConstituentTypes.some((t) => this.isTypeComparableTo(source, t));
+    }
+    if (source.kind === "variant") {
+      const result = this.isTypeComparableTo(source.getUnderlyingType(), target);
+      if (result) {
+        return true;
+      }
+    } else if (target.kind === "variant") {
+      const result = this.isTypeComparableTo(source, target.getUnderlyingType());
+      if (result) {
+        return true;
+      }
+    }
+    const integerType = this.analyzer.originalStandardTypes.integer;
+    const numberType = this.analyzer.originalStandardTypes.number;
+    if (source.equals(integerType) && target.equals(numberType) || source.equals(numberType) && target.equals(integerType)) {
+      return true;
+    }
+    if (source.kind === "function" && target.kind === "function") {
+      return source.equals(target);
+    }
+    if (source.kind === "structured" && target.kind === "structured") {
+      return this.analyzer.typeUtils.isTypeDerivedFromOrEqualsTo(source, target) || this.analyzer.typeUtils.isTypeDerivedFromOrEqualsTo(target, source);
+    }
+    return false;
+  }
+};
 var TypeUtils2 = class {
   constructor(analyzer) {
     this.analyzer = analyzer;
@@ -64285,6 +64413,9 @@ var TypeUtils2 = class {
     }
     return Query.any(this.allAspectsOfType(type), (a) => a.getEntity().getOriginalEntity() === aspectEntity.getOriginalEntity());
   }
+  areTypesComparable(type1, type2) {
+    return type1.isNullType || type2.isNullType || this.analyzer.isTypeComparableTo(type1, type2);
+  }
   collectBaseAndAliasedTypesRecursively(type, result) {
     switch (type.kind) {
       case "function": {
@@ -71716,6 +71847,12 @@ var UserDefinableBinaryOperatorResolver = class {
     const semanticContext = this.analyzer.semanticContext.containing(this.left);
     const typeMemberLookupContext = semanticContext.getTypeMemberLookupContext();
     const nonNullableLeftType = this.analyzer.excludeNullFromType(leftType);
+    if (!nonNullableLeftType.equals(leftType)) {
+      this.diagnostics?.addDiagnostic(this.analyzer.createDiagnostic(
+        2105 /* ExpressionCanBeNull */,
+        this.left
+      ));
+    }
     const leftTypeMemberLookup = TypeMemberLookup.ofType(this.analyzer, nonNullableLeftType);
     const operators = leftTypeMemberLookup.getNamedMembersByName(name, typeMemberLookupContext, 1 /* OnlyInstanceMembers */).filter((o) => o.kind === "method" && o.getParameters().length === 1);
     if (operators.length > 0) {
@@ -71851,6 +71988,12 @@ var UserDefinableUnaryOperatorResolver = class {
     const semanticContext = this.analyzer.semanticContext.containing(this.node.operand);
     const typeMemberLookupContext = semanticContext.getTypeMemberLookupContext();
     const nonNullableOperandType = this.analyzer.excludeNullFromType(operandType);
+    if (!nonNullableOperandType.equals(operandType)) {
+      this.diagnostics?.addDiagnostic(this.analyzer.createDiagnostic(
+        2105 /* ExpressionCanBeNull */,
+        this.node.operand
+      ));
+    }
     const typeMemberLookup = TypeMemberLookup.ofType(this.analyzer, nonNullableOperandType);
     const operators = typeMemberLookup.getNamedMembersByName(name, typeMemberLookupContext, 1 /* OnlyInstanceMembers */).filter((o) => o.kind === "method" && o.getParameters().length === 0);
     if (operators.length === 1) {

package/build/{chunk-NKLHVPAI.js → chunk-PCY52KYM.js}

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

package/build/{chunk-BUGHCVWW.js → chunk-WXKN3LZG.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-NKLHVPAI.js";
+} from "./chunk-PCY52KYM.js";
 import {
   ArtelVersion,
   Cached,
@@ -15,7 +15,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-DWHH53A7.js";
+} from "./chunk-KCEJTV3Q.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";

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

@@ -56,6 +56,7 @@ export declare abstract class Analyzer {
     get signatureComparer(): SignatureComparer;
     get conflictsCheck(): ConflictsCheck;
     get typeAssignabilityCheck(): TypeAssignabilityCheck;
+    get typeComparabilityCheck(): TypeComparabilityCheck;
     get overriddenMember(): OverriddenMember;
     get tsInterop(): TsInteropContext;
     constructor(state: CommonAnalyzerState);
@@ -69,6 +70,7 @@ export declare abstract class Analyzer {
     ifTypeReferenceThenReferencedType(type: types.Type): types.Type | undefined;
     isTypeAssignableTo(source: types.Type, target: types.Type): boolean;
     getTypeAssignabilityFlags(source: types.Type, target: types.Type): TypeAssignabilityFlags;
+    isTypeComparableTo(source: types.Type, target: types.Type): boolean;
     getUnambiguousTargetFunctionType(targetType: types.Type | undefined): types.FunctionType | undefined;
     getUnambiguousTargetArrayType(targetType: types.Type | undefined): types.Type | undefined;
     getUnambiguousTargetReferenceType(targetType: types.Type | undefined): types.Type | undefined;
@@ -179,6 +181,7 @@ export declare class CommonAnalyzerState {
     signatureComparer: SignatureComparer;
     conflictsCheck: ConflictsCheck;
     typeAssignabilityCheck: TypeAssignabilityCheck;
+    typeComparabilityCheck: TypeComparabilityCheck;
     overriddenMember: OverriddenMember;
     readonly tsInteropInputs: TsInteropInputs;
     readonly tsInterop: Cached<TsInteropContext>;
@@ -286,6 +289,11 @@ declare class TypeAssignabilityCheck {
     private areNewFlagsBetter;
     private getFlagCount;
 }
+declare class TypeComparabilityCheck {
+    private readonly analyzer;
+    constructor(analyzer: Analyzer);
+    isTypeComparableTo(source: types.Type, target: types.Type): boolean;
+}
 declare class TypeUtils {
     private readonly analyzer;
     constructor(analyzer: Analyzer);
@@ -302,6 +310,7 @@ declare class TypeUtils {
     compareSubstitutionsWithSimpleTypeComparer(substitutions1: types.Substitutions, substitutions2: types.Substitutions, comparer: SimpleTypeComparer): boolean;
     allAspectsOfType(type: types.Type): Iterable<types.StructuredType>;
     checkTypeIsBasedOnAspect(type: types.Type, aspectEntity: e.StructuredTypeEntity): boolean;
+    areTypesComparable(type1: types.Type, type2: types.Type): boolean;
     private collectBaseAndAliasedTypesRecursively;
     private getBaseTypesForCommonTypesSearch;
     private addTypeAndCollectAllBaseTypes;

package/build/types/analysis/a/SourceFileAnalyzer.d.ts

@@ -20,6 +20,7 @@ export declare class SourceFileAnalyzer {
     constructor(analyzer: Analyzer, sourceFile: project.SourceFileA);
     analyze(taskController: TaskController): Promise<Diagnostic[]>;
     private analyzeNode;
+    private checkBinaryExpression;
     private checkPackageVariantDeclaration;
     private checkTypeMemberDeclarationBlock;
     private checkAssumptionExpression;

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

@@ -267,6 +267,7 @@ export declare enum DiagnosticCode {
     OperatorCannotBeAsync = 2228,
     OperatorCannotContainTypeParameterDeclarations = 2229,
     TypeNameExpectedAtLastQualifier = 2230,
+    ExpressionsWithTypes0And1CannotBeCompared = 2231,
     CannotFindTsLibDirectoryBaseSearchPaths0 = 3000,
     SourceFile0IsNotPartOfThePackageAndWontBeLoaded = 3001,
     ProgramWithoutMainPackageCannotBeCompiled = 3002,

package/build/types/entities/Entity.d.ts

@@ -50,7 +50,7 @@ export type AccessorEntity = GetterEntity | SetterEntity;
 export declare function isAccessorEntity(entity: Entity): entity is AccessorEntity;
 export type EntityWithTypeParameters = EntityContainingTypeParameter;
 export declare function isEntityWithTypeParameters(entity: Entity): entity is EntityWithTypeParameters;
-export type EntityWithParameters = Exclude<EntityContainingParameter, PackageEntity>;
+export type EntityWithParameters = EntityContainingParameter;
 export declare function isEntityWithParameters(entity: Entity): entity is EntityWithParameters;
 export type NamedFunctionEntity = PackageFunctionEntity | MethodEntity | NestedFunctionEntity;
 export declare function isNamedFunctionEntity(entity: Entity): entity is NamedFunctionEntity;

package/build/types/entities/interfaces/VariableEntity.d.ts

@@ -2,7 +2,7 @@ import { Name } from '../../common/index.js';
 import * as treeA from '../../tree/a/index.js';
 import * as types from '../../types/index.js';
 import { IEntity } from '../IEntity.js';
-import { AnonymousFunctionEntity, ConstructorEntity, DefinitionKind, DestructorEntity, EntityHidingLevel, EntityKind, FunctionEntity, FunctionTypeEntity, GetterEntity, IndexerEntity, PackageEntity, PreservedReducedTypeEntityMemberInfo, SetterEntity, TextTranslationEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
+import { AnonymousFunctionEntity, ConstructorEntity, DefinitionKind, DestructorEntity, EntityHidingLevel, EntityKind, FunctionEntity, FunctionTypeEntity, GetterEntity, IndexerEntity, PreservedReducedTypeEntityMemberInfo, SetterEntity, TextTranslationEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
 export type VariableEntity = PackageVariableEntity | FieldEntity | ParameterEntity | LocalVariableEntity;
 interface IVariableEntity extends IEntity {
     readonly kind: EntityKind.Variable;
@@ -50,7 +50,7 @@ export declare enum LocalVariableKind {
     Enumeration = 1,
     Error = 2
 }
-export type EntityContainingParameter = FunctionEntity | IndexerEntity | ConstructorEntity | DestructorEntity | FunctionTypeEntity | PackageEntity;
+export type EntityContainingParameter = FunctionEntity | IndexerEntity | ConstructorEntity | DestructorEntity | FunctionTypeEntity | TextTranslationEntity;
 export type VariableEntityDefinition = {
     kind: DefinitionKind.Source;
     value: SourceVariableEntityDefinition;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artel/artc",
-  "version": "0.6.26021",
+  "version": "0.6.26022",
   "description": "Артель Компилятор | Artel Compiler",
   "author": "Nezaboodka Team <contact@nezaboodka.com>",
   "license": "Apache-2.0",