@artel/artc 0.6.25232 → 0.6.25233

package/build/{chunk-E72KEKQV.js → chunk-T4JAN46C.js}

@@ -617,7 +617,7 @@ var UniqueWithComparatorQuery = class extends Query {
 };
 
 // source/common/Constants.ts
-var ArtelVersion = true ? "0.6.25232" : "";
+var ArtelVersion = true ? "0.6.25233" : "";
 var ArtelSourceFileExtensions = [".\u0430\u0440\u0442", ".\u0430\u0440\u0442\u0435\u043B\u044C", ".art", ".artel"];
 var ArtelSourceFileExtensionSet = new Set(ArtelSourceFileExtensions);
 var ArtelSourceAndConfigurationFileExtensionSet = new Set(ArtelSourceFileExtensionSet).add(".json");
@@ -16862,18 +16862,26 @@ var IntersectionType = class {
     if (this === other) {
       return true;
     }
-    if (!(other.kind === "intersection" && this.unaliasedFlattenedTypes.length === other.unaliasedFlattenedTypes.length)) {
+    if (other.kind !== "intersection") {
       return false;
     }
-    const otherTypes = Array.from(other.unaliasedFlattenedTypes);
-    for (const type of this.unaliasedFlattenedTypes) {
-      const otherTypeIndex = otherTypes.findIndex((t) => t.equals(type));
-      if (otherTypeIndex === -1) {
-        return false;
+    const thisTypes = this.originalTypes;
+    const otherTypes = other.originalTypes;
+    if (thisTypes.length !== otherTypes.length) {
+      return false;
+    } else if (thisTypes.length === 0) {
+      return true;
+    } else {
+      const otherTypesMutable = Array.from(otherTypes);
+      for (const type of thisTypes) {
+        const otherTypeIndex = otherTypesMutable.findIndex((t) => t.equals(type));
+        if (otherTypeIndex === -1) {
+          return false;
+        }
+        ArrayUtils.removeElement(otherTypesMutable, otherTypeIndex);
       }
-      ArrayUtils.removeElement(otherTypes, otherTypeIndex);
+      return true;
     }
-    return true;
   }
   getSubstitutions() {
     return Substitutions.empty(this._analyzer);
@@ -17721,18 +17729,28 @@ var UnionType = class {
     if (this === other) {
       return true;
     }
-    if (!(other.kind === "union" && this.unaliasedFlattenedTypes.length === other.unaliasedFlattenedTypes.length)) {
+    if (other.kind !== "union") {
       return false;
     }
-    const otherTypes = Array.from(other.unaliasedFlattenedTypes);
-    for (const type of this.unaliasedFlattenedTypes) {
-      const otherTypeIndex = otherTypes.findIndex((t) => t.equals(type));
-      if (otherTypeIndex === -1) {
-        return false;
+    const thisTypes = this.originalTypes;
+    const otherTypes = other.originalTypes;
+    if (thisTypes.length !== otherTypes.length) {
+      return false;
+    } else if (thisTypes.length === 0) {
+      return true;
+    } else if (thisTypes.length === 2) {
+      return thisTypes[0].equals(otherTypes[0]) && thisTypes[1].equals(otherTypes[1]) || thisTypes[0].equals(otherTypes[1]) && thisTypes[1].equals(otherTypes[0]);
+    } else {
+      const otherTypesMutable = Array.from(otherTypes);
+      for (const type of thisTypes) {
+        const otherTypeIndex = otherTypesMutable.findIndex((t) => t.equals(type));
+        if (otherTypeIndex === -1) {
+          return false;
+        }
+        ArrayUtils.removeElement(otherTypesMutable, otherTypeIndex);
       }
-      ArrayUtils.removeElement(otherTypes, otherTypeIndex);
+      return true;
     }
-    return true;
   }
   getSubstitutions() {
     return Substitutions.empty(this._analyzer);
@@ -27893,6 +27911,7 @@ var ModifierValidator = class _ModifierValidator {
     this._diagnostics = _diagnostics;
     this._locale = _locale;
     this._dialect = _dialect;
+    this.effectiveModifiers = [];
   }
   static {
     this.allowedPackageMemberHidingModifiers = 17 /* HiddenInPackageOrWithoutLevel */ | 8 /* HiddenInFile */;
@@ -27997,9 +28016,9 @@ var ModifierValidator = class _ModifierValidator {
   validateTopLevelPackageMembers(list) {
     this.validatePackageMembers(list, 0 /* None */);
   }
-  validateTopLevelTypeMembers(list, declarationWithMembersKind, isTypeMarkedAbstract, isTypeMarkedBasic) {
+  validateTopLevelTypeMembers(memberList, declarationWithMembersKind, isTypeMarkedAbstract, isTypeMarkedBasic) {
     this.validateTypeMembers(
-      list,
+      memberList,
       declarationWithMembersKind,
       isTypeMarkedAbstract,
       isTypeMarkedBasic,
@@ -28081,104 +28100,141 @@ var ModifierValidator = class _ModifierValidator {
   }
   validatePackageMembers(list, parentGroupFlags) {
     for (const declaration of list.declarations) {
-      switch (declaration.kind) {
-        case 24 /* PackageMemberGroupDeclaration */: {
-          const groupFlags = this.validatePackageMemberModifierList(
-            declaration.modifierList,
-            2 /* MemberGroupDeclaration */,
-            parentGroupFlags
-          );
-          this.validatePackageMembers(declaration.declarationList, groupFlags);
-          break;
-        }
-        case 35 /* PackageVariableDeclaration */: {
-          const declarationKind = 11 /* VariableDeclaration */;
-          this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
-          this.validatePackageMemberCanBePlacedInGroupWithModifiers(declarationKind, declaration.name, parentGroupFlags);
-          break;
-        }
-        case 27 /* PackageFunctionDeclaration */: {
-          const declarationKind = 6 /* FunctionDeclaration */;
-          this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
-          this.validatePackageMemberCanBePlacedInGroupWithModifiers(declarationKind, declaration.name, parentGroupFlags);
-          break;
-        }
-        case 36 /* PackageVariableGetterDeclaration */: {
-          const declarationKind = 12 /* VariableGetterDeclaration */;
-          this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
-          this.validatePackageMemberCanBePlacedInGroupWithModifiers(declarationKind, declaration.name, parentGroupFlags);
-          break;
-        }
-        case 37 /* PackageVariableSetterDeclaration */: {
-          const declarationKind = 13 /* VariableSetterDeclaration */;
-          this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
-          this.validatePackageMemberCanBePlacedInGroupWithModifiers(declarationKind, declaration.name, parentGroupFlags);
-          break;
-        }
-        case 38 /* PackageVariantTypeDeclaration */: {
-          const declarationKind = 14 /* VariantTypeDeclaration */;
-          this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
-          this.validatePackageMemberCanBePlacedInGroupWithModifiers(declarationKind, declaration.name, parentGroupFlags);
-          break;
-        }
-        case 22 /* PackageAliasTypeDeclaration */: {
-          const declarationKind = 1 /* AliasTypeDeclaration */;
-          this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
-          this.validatePackageMemberCanBePlacedInGroupWithModifiers(declarationKind, declaration.name, parentGroupFlags);
-          break;
-        }
-        case 28 /* PackageFunctionTypeDeclaration */: {
-          const declarationKind = 7 /* FunctionTypeDeclaration */;
-          this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
-          this.validatePackageMemberCanBePlacedInGroupWithModifiers(declarationKind, declaration.name, parentGroupFlags);
-          break;
-        }
-        case 33 /* PackageStructuredTypeDeclaration */: {
-          let declarationKind;
-          switch (declaration.body.structuredTypeKindKeyword.keywordKind) {
-            case 3 /* Aspect */:
-              declarationKind = 10 /* AspectTypeDeclaration */;
-              break;
-            case 4 /* Object */:
-              declarationKind = 8 /* ObjectTypeDeclaration */;
-              break;
-            case 5 /* PlainObject */:
-              declarationKind = 9 /* PlainObjectTypeDeclaration */;
-              break;
-            default:
-              Debug.never(declaration.body.structuredTypeKindKeyword);
+      this.effectiveModifiers.push(declaration.modifierList);
+      try {
+        switch (declaration.kind) {
+          case 24 /* PackageMemberGroupDeclaration */: {
+            const groupFlags = this.validatePackageMemberModifierList(
+              declaration.modifierList,
+              2 /* MemberGroupDeclaration */,
+              parentGroupFlags
+            );
+            this.validatePackageMembers(declaration.declarationList, groupFlags);
+            break;
           }
-          this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
-          this.validatePackageMemberCanBePlacedInGroupWithModifiers(declarationKind, declaration.name, parentGroupFlags);
-          break;
-        }
-        case 40 /* TypeExtensionDeclaration */: {
-          const declarationKind = 3 /* TypeExtensionDeclaration */;
-          this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
-          this.validatePackageMemberCanBePlacedInGroupWithModifiers(
-            declarationKind,
-            declaration.extendedTypeClause,
-            parentGroupFlags
-          );
-          break;
-        }
-        case 43 /* InvalidPackageMemberDeclaration */: {
-          const declarationKind = 15 /* InvalidDeclaration */;
-          this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
-          this.validatePackageMemberCanBePlacedInGroupWithModifiers(declarationKind, declaration, parentGroupFlags);
-          break;
+          case 35 /* PackageVariableDeclaration */: {
+            const declarationKind = 11 /* VariableDeclaration */;
+            this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
+            this.validatePackageMemberCanBePlacedInGroupWithModifiers(
+              declarationKind,
+              declaration.name,
+              parentGroupFlags
+            );
+            break;
+          }
+          case 27 /* PackageFunctionDeclaration */: {
+            const declarationKind = 6 /* FunctionDeclaration */;
+            this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
+            this.validatePackageMemberCanBePlacedInGroupWithModifiers(
+              declarationKind,
+              declaration.name,
+              parentGroupFlags
+            );
+            break;
+          }
+          case 36 /* PackageVariableGetterDeclaration */: {
+            const declarationKind = 12 /* VariableGetterDeclaration */;
+            this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
+            this.validatePackageMemberCanBePlacedInGroupWithModifiers(
+              declarationKind,
+              declaration.name,
+              parentGroupFlags
+            );
+            break;
+          }
+          case 37 /* PackageVariableSetterDeclaration */: {
+            const declarationKind = 13 /* VariableSetterDeclaration */;
+            this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
+            this.validatePackageMemberCanBePlacedInGroupWithModifiers(
+              declarationKind,
+              declaration.name,
+              parentGroupFlags
+            );
+            break;
+          }
+          case 38 /* PackageVariantTypeDeclaration */: {
+            const declarationKind = 14 /* VariantTypeDeclaration */;
+            this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
+            this.validatePackageMemberCanBePlacedInGroupWithModifiers(
+              declarationKind,
+              declaration.name,
+              parentGroupFlags
+            );
+            break;
+          }
+          case 22 /* PackageAliasTypeDeclaration */: {
+            const declarationKind = 1 /* AliasTypeDeclaration */;
+            this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
+            this.validatePackageMemberCanBePlacedInGroupWithModifiers(
+              declarationKind,
+              declaration.name,
+              parentGroupFlags
+            );
+            break;
+          }
+          case 28 /* PackageFunctionTypeDeclaration */: {
+            const declarationKind = 7 /* FunctionTypeDeclaration */;
+            this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
+            this.validatePackageMemberCanBePlacedInGroupWithModifiers(
+              declarationKind,
+              declaration.name,
+              parentGroupFlags
+            );
+            break;
+          }
+          case 33 /* PackageStructuredTypeDeclaration */: {
+            let declarationKind;
+            switch (declaration.body.structuredTypeKindKeyword.keywordKind) {
+              case 3 /* Aspect */:
+                declarationKind = 10 /* AspectTypeDeclaration */;
+                break;
+              case 4 /* Object */:
+                declarationKind = 8 /* ObjectTypeDeclaration */;
+                break;
+              case 5 /* PlainObject */:
+                declarationKind = 9 /* PlainObjectTypeDeclaration */;
+                break;
+              default:
+                Debug.never(declaration.body.structuredTypeKindKeyword);
+            }
+            this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
+            this.validatePackageMemberCanBePlacedInGroupWithModifiers(
+              declarationKind,
+              declaration.name,
+              parentGroupFlags
+            );
+            break;
+          }
+          case 40 /* TypeExtensionDeclaration */: {
+            const declarationKind = 3 /* TypeExtensionDeclaration */;
+            this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
+            this.validatePackageMemberCanBePlacedInGroupWithModifiers(
+              declarationKind,
+              declaration.extendedTypeClause,
+              parentGroupFlags
+            );
+            break;
+          }
+          case 43 /* InvalidPackageMemberDeclaration */: {
+            const declarationKind = 15 /* InvalidDeclaration */;
+            this.validatePackageMemberModifierList(declaration.modifierList, declarationKind, parentGroupFlags);
+            this.validatePackageMemberCanBePlacedInGroupWithModifiers(declarationKind, declaration, parentGroupFlags);
+            break;
+          }
+          case 26 /* PackageEntryPointDeclaration */:
+            this.validatePackageEntryPointDeclaration(declaration, parentGroupFlags);
+            break;
+          case 25 /* PackageConstructorDeclaration */:
+            this.validatePackageConstructorDeclaration(declaration, parentGroupFlags);
+            break;
+          case 21 /* TranslationsDeclaration */:
+            this.validateTranslationsDeclaration(declaration, parentGroupFlags);
+            break;
+          default:
+            Debug.never(declaration);
         }
-        case 26 /* PackageEntryPointDeclaration */:
-          this.validatePackageEntryPointDeclaration(declaration, parentGroupFlags);
-          break;
-        case 25 /* PackageConstructorDeclaration */:
-          this.validatePackageConstructorDeclaration(declaration, parentGroupFlags);
-          break;
-        case 21 /* TranslationsDeclaration */:
-          this.validateTranslationsDeclaration(declaration, parentGroupFlags);
-          break;
-        default:
-          Debug.never(declaration);
+      } finally {
+        this.effectiveModifiers.pop();
       }
     }
   }
@@ -28206,7 +28262,10 @@ var ModifierValidator = class _ModifierValidator {
               modifier
             ));
           } else if ((flags & 64 /* Abstract */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 38 /* Abstract */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(64 /* Abstract */)
+            );
           }
           flags |= flag;
           break;
@@ -28221,7 +28280,10 @@ var ModifierValidator = class _ModifierValidator {
               modifier
             ));
           } else if ((flags & 128 /* Basic */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 17 /* Basic */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(128 /* Basic */)
+            );
           }
           flags |= flag;
           break;
@@ -28231,7 +28293,10 @@ var ModifierValidator = class _ModifierValidator {
           if ((flags & flag) !== 0) {
             this.reportDuplicateModifier(modifier, flag, parentGroupFlags);
           } else if (declarationKind === 2 /* MemberGroupDeclaration */ && (flags & 512 /* Async */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 40 /* Async */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(512 /* Async */)
+            );
           } else if (!(declarationKind === 2 /* MemberGroupDeclaration */ || declarationKind === 11 /* VariableDeclaration */)) {
             this.reportModifierIsNotAllowedHere(modifier);
           }
@@ -28243,7 +28308,10 @@ var ModifierValidator = class _ModifierValidator {
           if ((flags & flag) !== 0) {
             this.reportDuplicateModifier(modifier, flag, parentGroupFlags);
           } else if (declarationKind === 2 /* MemberGroupDeclaration */ && (flags & 1024 /* Const */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 36 /* Const */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(1024 /* Const */)
+            );
           } else if (!(declarationKind === 2 /* MemberGroupDeclaration */ || declarationKind === 6 /* FunctionDeclaration */)) {
             this.reportModifierIsNotAllowedHere(modifier);
           }
@@ -28266,7 +28334,10 @@ var ModifierValidator = class _ModifierValidator {
     if (presentNotAllowedFlags !== 0 /* None */) {
       this.forEachModifierFlag(
         presentNotAllowedFlags,
-        (f) => this.reportDeclarationCanNotBePlacedInGroupWithModifier(nodeForDiagnostic, f)
+        (f) => {
+          const modifier = this.findModifier(f);
+          this.reportDeclarationCanNotBePlacedInGroupWithModifier(nodeForDiagnostic, modifier);
+        }
       );
     }
   }
@@ -28300,115 +28371,124 @@ var ModifierValidator = class _ModifierValidator {
       ));
     }
   }
-  validateTypeMembers(list, declarationWithMembersKind, isTypeMarkedAbstract, isTypeMarkedBasic, parentGroupFlags) {
-    for (const declaration of list.members) {
-      const flags = this.validateTypeMemberModifierList(
-        declaration.modifierList,
-        declaration.kind,
-        declarationWithMembersKind,
-        isTypeMarkedAbstract,
-        isTypeMarkedBasic,
-        parentGroupFlags
-      );
-      switch (declaration.kind) {
-        case 44 /* TypeMemberGroupDeclaration */:
-          this.validateTypeMembers(
-            declaration.memberBlock.memberList,
-            declarationWithMembersKind,
-            isTypeMarkedAbstract,
-            isTypeMarkedBasic,
-            flags
-          );
-          break;
-        case 45 /* ConstructorDeclaration */:
-          this.validateTypeMemberCanBePlacedInGroupWithModifiers(
-            declaration.kind,
-            declaration.creationKeyword,
-            parentGroupFlags
-          );
-          break;
-        case 46 /* DestructorDeclaration */:
-          this.validateTypeMemberCanBePlacedInGroupWithModifiers(
-            declaration.kind,
-            declaration.destructionKeyword,
-            parentGroupFlags
-          );
-          break;
-        case 47 /* IndexedElementGetterDeclaration */:
-          this.validateTypeMemberCanBePlacedInGroupWithModifiers(
-            declaration.kind,
-            declaration.parameterClause,
-            parentGroupFlags
-          );
-          break;
-        case 48 /* IndexedElementSetterDeclaration */:
-          this.validateTypeMemberCanBePlacedInGroupWithModifiers(
-            declaration.kind,
-            declaration.parameterClause,
-            parentGroupFlags
-          );
-          break;
-        case 50 /* DereferencedVariableGetterDeclaration */:
-          this.validateTypeMemberCanBePlacedInGroupWithModifiers(
-            declaration.kind,
-            declaration.caretToken,
-            parentGroupFlags
-          );
-          break;
-        case 51 /* DereferencedVariableSetterDeclaration */:
-          this.validateTypeMemberCanBePlacedInGroupWithModifiers(
-            declaration.kind,
-            declaration.caretToken,
-            parentGroupFlags
-          );
-          break;
-        case 52 /* MethodDeclaration */:
-          this.validateTypeMemberCanBePlacedInGroupWithModifiers(
-            declaration.kind,
-            declaration.name,
-            parentGroupFlags
-          );
-          break;
-        case 53 /* OperatorDeclaration */:
-          this.validateTypeMemberCanBePlacedInGroupWithModifiers(
-            declaration.kind,
-            declaration.name,
-            parentGroupFlags
-          );
-          break;
-        case 54 /* FieldDeclaration */:
-          this.validateFieldCanBePlacedInGroupWithModifiers(declaration, declarationWithMembersKind, parentGroupFlags);
-          break;
-        case 55 /* FieldGetterDeclaration */:
-          this.validateTypeMemberCanBePlacedInGroupWithModifiers(
-            declaration.kind,
-            declaration.name,
-            parentGroupFlags
-          );
-          break;
-        case 56 /* FieldSetterDeclaration */:
-          this.validateTypeMemberCanBePlacedInGroupWithModifiers(
-            declaration.kind,
-            declaration.name,
-            parentGroupFlags
-          );
-          break;
-        case 57 /* InvalidTypeMemberDeclaration */:
-          this.validateTypeMemberCanBePlacedInGroupWithModifiers(
-            declaration.kind,
-            declaration,
-            parentGroupFlags
-          );
-          break;
-        case 142 /* VariantDeclaration */:
-          this.validateTypeMemberCanBePlacedInGroupWithModifiers(
-            declaration.kind,
-            declaration.name,
-            parentGroupFlags
-          );
-          break;
-        default:
-          Debug.never(declaration);
+  validateTypeMembers(memberList, declarationWithMembersKind, isTypeMarkedAbstract, isTypeMarkedBasic, parentGroupFlags) {
+    for (const declaration of memberList.members) {
+      this.effectiveModifiers.push(declaration.modifierList);
+      try {
+        const flags = this.validateTypeMemberModifierList(
+          declaration.modifierList,
+          declaration.kind,
+          declarationWithMembersKind,
+          isTypeMarkedAbstract,
+          isTypeMarkedBasic,
+          parentGroupFlags
+        );
+        switch (declaration.kind) {
+          case 44 /* TypeMemberGroupDeclaration */:
+            this.validateTypeMembers(
+              declaration.memberBlock.memberList,
+              declarationWithMembersKind,
+              isTypeMarkedAbstract,
+              isTypeMarkedBasic,
+              flags
+            );
+            break;
+          case 45 /* ConstructorDeclaration */:
+            this.validateTypeMemberCanBePlacedInGroupWithModifiers(
+              declaration.kind,
+              declaration.creationKeyword,
+              parentGroupFlags
+            );
+            break;
+          case 46 /* DestructorDeclaration */:
+            this.validateTypeMemberCanBePlacedInGroupWithModifiers(
+              declaration.kind,
+              declaration.destructionKeyword,
+              parentGroupFlags
+            );
+            break;
+          case 47 /* IndexedElementGetterDeclaration */:
+            this.validateTypeMemberCanBePlacedInGroupWithModifiers(
+              declaration.kind,
+              declaration.parameterClause,
+              parentGroupFlags
+            );
+            break;
+          case 48 /* IndexedElementSetterDeclaration */:
+            this.validateTypeMemberCanBePlacedInGroupWithModifiers(
+              declaration.kind,
+              declaration.parameterClause,
+              parentGroupFlags
+            );
+            break;
+          case 50 /* DereferencedVariableGetterDeclaration */:
+            this.validateTypeMemberCanBePlacedInGroupWithModifiers(
+              declaration.kind,
+              declaration.caretToken,
+              parentGroupFlags
+            );
+            break;
+          case 51 /* DereferencedVariableSetterDeclaration */:
+            this.validateTypeMemberCanBePlacedInGroupWithModifiers(
+              declaration.kind,
+              declaration.caretToken,
+              parentGroupFlags
+            );
+            break;
+          case 52 /* MethodDeclaration */:
+            this.validateTypeMemberCanBePlacedInGroupWithModifiers(
+              declaration.kind,
+              declaration.name,
+              parentGroupFlags
+            );
+            break;
+          case 53 /* OperatorDeclaration */:
+            this.validateTypeMemberCanBePlacedInGroupWithModifiers(
+              declaration.kind,
+              declaration.name,
+              parentGroupFlags
+            );
+            break;
+          case 54 /* FieldDeclaration */:
+            this.validateFieldCanBePlacedInGroupWithModifiers(
+              declaration,
+              declarationWithMembersKind,
+              parentGroupFlags
+            );
+            break;
+          case 55 /* FieldGetterDeclaration */:
+            this.validateTypeMemberCanBePlacedInGroupWithModifiers(
+              declaration.kind,
+              declaration.name,
+              parentGroupFlags
+            );
+            break;
+          case 56 /* FieldSetterDeclaration */:
+            this.validateTypeMemberCanBePlacedInGroupWithModifiers(
+              declaration.kind,
+              declaration.name,
+              parentGroupFlags
+            );
+            break;
+          case 57 /* InvalidTypeMemberDeclaration */:
+            this.validateTypeMemberCanBePlacedInGroupWithModifiers(
+              declaration.kind,
+              declaration,
+              parentGroupFlags
+            );
+            break;
+          case 142 /* VariantDeclaration */:
+            this.validateTypeMemberCanBePlacedInGroupWithModifiers(
+              declaration.kind,
+              declaration.name,
+              parentGroupFlags
+            );
+            break;
+          default:
+            Debug.never(declaration);
+        }
+      } finally {
+        this.effectiveModifiers.pop();
       }
     }
   }
@@ -28426,9 +28506,15 @@ var ModifierValidator = class _ModifierValidator {
               modifier
             ));
           } else if ((flag & 3 /* HiddenInTypeOrWithoutLevel */) !== 0 && (flags & 64 /* Abstract */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 38 /* Abstract */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(64 /* Abstract */)
+            );
           } else if ((flag & 3 /* HiddenInTypeOrWithoutLevel */) !== 0 && (flags & 128 /* Basic */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 17 /* Basic */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(128 /* Basic */)
+            );
           }
           flags |= flag;
           break;
@@ -28447,13 +28533,18 @@ var ModifierValidator = class _ModifierValidator {
           } else if ((flags & 3 /* HiddenInTypeOrWithoutLevel */) !== 0) {
             this.reportModifierCanNotBeUsedWithAnotherModifier(
               modifier,
-              37 /* Hidden */,
-              51 /* InType */
+              this.findModifier(3 /* HiddenInTypeOrWithoutLevel */)
             );
           } else if ((flags & 32 /* Static */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 41 /* Static */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(32 /* Static */)
+            );
           } else if ((flags & 128 /* Basic */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 17 /* Basic */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(128 /* Basic */)
+            );
           }
           flags |= flag;
           break;
@@ -28482,13 +28573,18 @@ var ModifierValidator = class _ModifierValidator {
           } else if ((flags & 3 /* HiddenInTypeOrWithoutLevel */) !== 0) {
             this.reportModifierCanNotBeUsedWithAnotherModifier(
               modifier,
-              37 /* Hidden */,
-              51 /* InType */
+              this.findModifier(3 /* HiddenInTypeOrWithoutLevel */)
             );
           } else if ((flags & 64 /* Abstract */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 38 /* Abstract */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(64 /* Abstract */)
+            );
           } else if ((flags & 32 /* Static */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 41 /* Static */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(32 /* Static */)
+            );
           }
           flags |= flag;
           break;
@@ -28505,7 +28601,10 @@ var ModifierValidator = class _ModifierValidator {
           } else if (!this.typeMemberAllowsOverrideModifier(typeMemberDeclarationKind)) {
             this.reportModifierIsNotAllowedHere(modifier);
           } else if ((flags & 32 /* Static */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 41 /* Static */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(32 /* Static */)
+            );
           }
           flags |= flag;
           break;
@@ -28517,11 +28616,20 @@ var ModifierValidator = class _ModifierValidator {
           } else if (!this.typeMemberAllowsStaticModifier(typeMemberDeclarationKind)) {
             this.reportModifierIsNotAllowedHere(modifier);
           } else if ((flags & 64 /* Abstract */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 38 /* Abstract */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(64 /* Abstract */)
+            );
           } else if ((flags & 128 /* Basic */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 17 /* Basic */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(128 /* Basic */)
+            );
           } else if ((flags & 256 /* Override */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 39 /* Override */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(256 /* Override */)
+            );
           }
           flags |= flag;
           break;
@@ -28531,7 +28639,10 @@ var ModifierValidator = class _ModifierValidator {
           if ((flags & flag) !== 0) {
             this.reportDuplicateModifier(modifier, flag, parentGroupFlags);
           } else if (typeMemberDeclarationKind === 44 /* TypeMemberGroupDeclaration */ && (flags & 512 /* Async */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 40 /* Async */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(512 /* Async */)
+            );
           } else if (!(typeMemberDeclarationKind === 44 /* TypeMemberGroupDeclaration */ || typeMemberDeclarationKind === 54 /* FieldDeclaration */)) {
             this.reportModifierIsNotAllowedHere(modifier);
           }
@@ -28543,7 +28654,10 @@ var ModifierValidator = class _ModifierValidator {
           if ((flags & flag) !== 0) {
             this.reportDuplicateModifier(modifier, flag, parentGroupFlags);
           } else if (typeMemberDeclarationKind === 44 /* TypeMemberGroupDeclaration */ && (flags & 1024 /* Const */) !== 0) {
-            this.reportModifierCanNotBeUsedWithAnotherModifier(modifier, 36 /* Const */);
+            this.reportModifierCanNotBeUsedWithAnotherModifier(
+              modifier,
+              this.findModifier(1024 /* Const */)
+            );
           } else if (!(typeMemberDeclarationKind === 44 /* TypeMemberGroupDeclaration */ || typeMemberDeclarationKind === 52 /* MethodDeclaration */)) {
             this.reportModifierIsNotAllowedHere(modifier);
           }
@@ -28562,14 +28676,18 @@ var ModifierValidator = class _ModifierValidator {
     if (presentNotAllowedFlags !== 0 /* None */) {
       this.forEachModifierFlag(
         presentNotAllowedFlags,
-        (f) => this.reportDeclarationCanNotBePlacedInGroupWithModifier(nodeForDiagnostic, f)
+        (f) => {
+          const modifier = this.findModifier(f);
+          this.reportDeclarationCanNotBePlacedInGroupWithModifier(nodeForDiagnostic, modifier);
+        }
       );
     }
   }
   validateFieldCanBePlacedInGroupWithModifiers(node, declarationWithMembersKind, parentGroupFlags) {
     this.validateTypeMemberCanBePlacedInGroupWithModifiers(node.kind, node.name, parentGroupFlags);
     if ((parentGroupFlags & 128 /* Basic */) !== 0 && declarationWithMembersKind === 2 /* AspectType */) {
-      this.reportDeclarationCanNotBePlacedInGroupWithModifier(node.name, 128 /* Basic */);
+      const modifier = this.findModifier(128 /* Basic */);
+      this.reportDeclarationCanNotBePlacedInGroupWithModifier(node.name, modifier);
     }
   }
   typeMemberAllowsAbstractModifier(kind) {
@@ -28589,25 +28707,34 @@ var ModifierValidator = class _ModifierValidator {
     this._diagnostics.addDiagnostic(this._analyzer.createNodeDiagnostic(code, node, [this.displayModifierNode(node)]));
   }
   reportDuplicateHiddenModifier(node, parentGroupFlags) {
-    const code = (parentGroupFlags & 31 /* AnyHiddenModifier */) === 0 ? 320 /* ModifierListAlreadyContains0Modifier */ : 321 /* ModifierListOfOuterDeclarationGroupAlreadyContains0Modifier */;
-    this._diagnostics.addDiagnostic(this._analyzer.createNodeDiagnostic(
-      code,
-      node,
-      [this.displayModifier(37 /* Hidden */)]
-    ));
+    let diagnostic;
+    if ((parentGroupFlags & 31 /* AnyHiddenModifier */) === 0) {
+      diagnostic = this._analyzer.createNodeDiagnostic(
+        320 /* ModifierListAlreadyContains0Modifier */,
+        node,
+        [this.displayModifierNode(node, false)]
+      );
+    } else {
+      diagnostic = this._analyzer.createNodeDiagnostic(
+        321 /* ModifierListOfOuterDeclarationGroupAlreadyContains0Modifier */,
+        node,
+        [this.displayModifierNode(this.findModifier(31 /* AnyHiddenModifier */))]
+      );
+    }
+    this._diagnostics.addDiagnostic(diagnostic);
   }
-  reportDeclarationCanNotBePlacedInGroupWithModifier(nodeForDiagnostic, modifierFlag) {
+  reportDeclarationCanNotBePlacedInGroupWithModifier(nodeForDiagnostic, modifier) {
     this._diagnostics.addDiagnostic(this._analyzer.createNodeDiagnostic(
       323 /* DeclarationCanNotBePlacedInGroupHaving0Modifier */,
       nodeForDiagnostic,
-      [this.displayModifierFlag(modifierFlag)]
+      [this.displayModifierNode(modifier)]
     ));
   }
-  reportModifierCanNotBeUsedWithAnotherModifier(firstModifier, secondModifierKind, secondModifierLevel) {
+  reportModifierCanNotBeUsedWithAnotherModifier(firstModifier, secondModifier) {
     this._diagnostics.addDiagnostic(this._analyzer.createNodeDiagnostic(
       330 /* _0ModifierCanNotBeUsedWith1Modifier */,
       firstModifier,
-      [this.displayModifierNode(firstModifier), this.displayModifier(secondModifierKind, secondModifierLevel)]
+      [this.displayModifierNode(firstModifier), this.displayModifierNode(secondModifier)]
     ));
   }
   reportModifierIsNotAllowedHere(node) {
@@ -28617,52 +28744,20 @@ var ModifierValidator = class _ModifierValidator {
       [this.displayModifierNode(node)]
     ));
   }
-  displayModifierNode(node) {
-    let result = node.value.tokens.map((t) => t.value).join(" ");
-    if (node.level !== void 0) {
-      result += `(${node.level.tokens.map((t) => t.value).join(" ")})`;
-    }
-    return result;
-  }
-  displayModifierFlag(flag) {
-    switch (flag) {
-      case 1 /* HiddenWithoutLevel */:
-        return this.displayModifier(37 /* Hidden */);
-      case 2 /* HiddenInType */:
-        return this.displayModifier(37 /* Hidden */, 51 /* InType */);
-      case 4 /* HiddenInHierarchy */:
-        return this.displayModifier(37 /* Hidden */, 48 /* InHierarchy */);
-      case 8 /* HiddenInFile */:
-        return this.displayModifier(37 /* Hidden */, 49 /* InFile */);
-      case 16 /* HiddenInPackage */:
-        return this.displayModifier(37 /* Hidden */, 50 /* InPackage */);
-      case 128 /* Basic */:
-        return this.displayModifier(17 /* Basic */);
-      case 32 /* Static */:
-        return this.displayModifier(41 /* Static */);
-      case 64 /* Abstract */:
-        return this.displayModifier(38 /* Abstract */);
-      case 256 /* Override */:
-        return this.displayModifier(39 /* Override */);
-      case 512 /* Async */:
-        return this.displayModifier(40 /* Async */);
-      case 1024 /* Const */:
-        return this.displayModifier(36 /* Const */);
-      case 0 /* None */:
-      case 2048 /* NotComputed */:
-      case 31 /* AnyHiddenModifier */:
-      case 17 /* HiddenInPackageOrWithoutLevel */:
-      case 3 /* HiddenInTypeOrWithoutLevel */:
-        return "";
-      default:
-        Debug.typeIsAssignableTo();
-        return "";
+  findModifier(modifierFlags) {
+    for (const groupModifiers of this.effectiveModifiers) {
+      for (const modifier of groupModifiers.modifiers) {
+        if ((modifierFlags & modifierToModifierFlag(modifier)) !== 0) {
+          return modifier;
+        }
+      }
     }
+    Debug.unreachable();
   }
-  displayModifier(kind, level) {
-    let result = LocalizationHelper.localizeKeywordAndTakeFirst(kind, this._locale, this._dialect);
-    if (level !== void 0) {
-      result += `(${LocalizationHelper.localizeKeywordAndTakeFirst(level, this._locale, this._dialect)})`;
+  displayModifierNode(node, withLevel = true) {
+    let result = node.value.tokens.map((t) => t.value).join(" ");
+    if (withLevel && node.level !== void 0) {
+      result += `(${node.level.tokens.map((t) => t.value).join(" ")})`;
     }
     return result;
   }
@@ -43223,17 +43318,21 @@ var OverriddenMember = class {
     this._overriddenAndShadowedOperators = /* @__PURE__ */ new Map();
     this._overriddenAndShadowedIndexers = /* @__PURE__ */ new Map();
     this._overriddenAndShadowedDereferenceOperators = /* @__PURE__ */ new Map();
-    this._fieldFinder = this.findOverriddenOrShadowedFieldInType.bind(this);
-    this._methodFinder = this.findOverriddenOrShadowedMethodInType.bind(this);
+    this._namedMemberFinder = this.findOverriddenOrShadowedNamedMemberInType.bind(this);
     this._operatorFinder = this.findOverriddenOrShadowedOperatorInType.bind(this);
     this._indexerFinder = this.findOverriddenOrShadowedIndexerInType.bind(this);
     this._dereferenceOperatorFinder = this.findOverriddenOrShadowedDereferenceOperatorInType.bind(this);
+    this._isField = (m) => m.kind === "field";
+    this._isMethod = (m) => m.kind === "method";
+    this._isOperator = (m) => m.kind === "operator";
+    this._isIndexer = (m) => m.kind === "indexer";
+    this._isDereferenceOperator = (m) => m.kind === "dereference-operator";
   }
   getOverriddenAndShadowedFields(node) {
     let result = this._overriddenAndShadowedFields.get(node);
     if (result === void 0) {
       const entity = node.kind === 54 /* FieldDeclaration */ ? this._analyzer.entity.ofFieldDeclaration(node) : this._analyzer.entity.ofComputedFieldDeclaration(node);
-      result = this.findOverriddenMembers(entity, node, this._fieldFinder);
+      result = this.findOverriddenMembers(entity, node, this._isField, this._namedMemberFinder);
       this._overriddenAndShadowedFields.set(node, result);
     }
     return result;
@@ -43242,7 +43341,7 @@ var OverriddenMember = class {
     let result = this._overriddenAndShadowedMethods.get(node);
     if (result === void 0) {
       const entity = this._analyzer.entity.ofMethodDeclaration(node);
-      result = this.findOverriddenMembers(entity, node, this._methodFinder);
+      result = this.findOverriddenMembers(entity, node, this._isMethod, this._namedMemberFinder);
       this._overriddenAndShadowedMethods.set(node, result);
     }
     return result;
@@ -43251,7 +43350,7 @@ var OverriddenMember = class {
     let result = this._overriddenAndShadowedOperators.get(node);
     if (result === void 0) {
       const entity = this._analyzer.entity.ofOperatorDeclaration(node);
-      result = this.findOverriddenMembers(entity, node, this._operatorFinder);
+      result = this.findOverriddenMembers(entity, node, this._isOperator, this._operatorFinder);
       this._overriddenAndShadowedOperators.set(node, result);
     }
     return result;
@@ -43260,7 +43359,7 @@ var OverriddenMember = class {
     let result = this._overriddenAndShadowedIndexers.get(node);
     if (result === void 0) {
       const entity = this._analyzer.entity.ofIndexerDeclaration(node);
-      result = this.findOverriddenMembers(entity, node, this._indexerFinder);
+      result = this.findOverriddenMembers(entity, node, this._isIndexer, this._indexerFinder);
       this._overriddenAndShadowedIndexers.set(node, result);
     }
     return result;
@@ -43269,7 +43368,7 @@ var OverriddenMember = class {
     let result = this._overriddenAndShadowedDereferenceOperators.get(node);
     if (result === void 0) {
       const entity = this._analyzer.entity.ofDereferenceOperatorDeclaration(node);
-      result = this.findOverriddenMembers(entity, node, this._dereferenceOperatorFinder);
+      result = this.findOverriddenMembers(entity, node, this._isDereferenceOperator, this._dereferenceOperatorFinder);
       this._overriddenAndShadowedDereferenceOperators.set(node, result);
     }
     return result;
@@ -43309,26 +43408,35 @@ var OverriddenMember = class {
         Debug.never(member);
     }
   }
-  findOverriddenMembers(entity, contextualNode, overriddenOrShadowedMemberFinder) {
+  findOverriddenMembers(entity, contextualNode, isMemberOfCorrectKind, overriddenOrShadowedMemberFinder) {
     const overriddenMembers = new Array();
     const shadowedMembers = new Array();
     if (this.entityCanOverrideOrShadow(entity)) {
       for (const lookup of this.enumerateTypeMemberLookups(entity, contextualNode)) {
         const overriddenOrShadowedMember = overriddenOrShadowedMemberFinder(entity, lookup);
         if (overriddenOrShadowedMember !== void 0) {
+          if (!isMemberOfCorrectKind(overriddenOrShadowedMember)) {
+            if (!shadowedMembers.some((m) => m.value.equals(overriddenOrShadowedMember))) {
+              shadowedMembers.push(new ShadowedMemberInfo(
+                overriddenOrShadowedMember,
+                0 /* BaseMemberHasDifferentKind */
+              ));
+            }
+            continue;
+          }
           const overriddenOrShadowedMemberEntity = overriddenOrShadowedMember.getEntity();
           let shadowReason;
           if (!this.entityCanBeOverridden(overriddenOrShadowedMemberEntity)) {
-            shadowReason = 0 /* BaseMemberCanNotBeOverridden */;
+            shadowReason = 1 /* BaseMemberCanNotBeOverridden */;
           } else if (!entity.isOverride() && !TypeMemberEntity.isAbstract(overriddenOrShadowedMember.getEntity())) {
-            shadowReason = 1 /* NoOverrideModifier */;
+            shadowReason = 2 /* NoOverrideModifier */;
           }
-          if (shadowReason === void 0 || shadowReason === 1 /* NoOverrideModifier */) {
+          if (shadowReason === void 0 || shadowReason === 2 /* NoOverrideModifier */) {
             const overridingType = this.getEntityTypeOrReturnType(entity);
             const overriddenType = this.getMemberTypeOrReturnType(overriddenOrShadowedMember);
             const typeAssignabilityFlags = this._analyzer.getTypeAssignabilityFlags(overridingType, overriddenType);
             if ((typeAssignabilityFlags & (1 /* NotAssignable */ | 16 /* ImplicitConversion */)) !== 0) {
-              shadowReason = shadowReason === 1 /* NoOverrideModifier */ ? 2 /* NoOverrideModifierAndTypeOrReturnTypeMismatch */ : 3 /* TypeOrReturnTypeMismatch */;
+              shadowReason = shadowReason === 2 /* NoOverrideModifier */ ? 3 /* NoOverrideModifierAndTypeOrReturnTypeMismatch */ : 4 /* TypeOrReturnTypeMismatch */;
             }
           }
           if (shadowReason === void 0) {
@@ -43345,14 +43453,16 @@ var OverriddenMember = class {
     }
     return new OverriddenAndShadowedMembers(overriddenMembers, shadowedMembers);
   }
-  findOverriddenOrShadowedFieldInType(variable, typeMemberLookup) {
+  findOverriddenOrShadowedNamedMemberInType(entity, typeMemberLookup) {
     return typeMemberLookup.getNamedMembersByName(new SearchName(
-      variable.getName(),
-      (variable.getName().flags & 2 /* OriginalName */) !== 0
-    )).find((m) => m.value.kind === "field")?.value;
-  }
-  findOverriddenOrShadowedMethodInType(method, typeMemberLookup) {
-    return typeMemberLookup.getNamedMembersByName(new SearchName(method.getName(), (method.getName().flags & 2 /* OriginalName */) !== 0)).find((m) => m.value.kind === "method" && this.checkMethodOverridesOrShadowsMethod(method, m.value))?.value;
+      entity.getName(),
+      (entity.getName().flags & 2 /* OriginalName */) !== 0
+    )).find((m) => {
+      if (entity.kind === 1 /* Function */ && m.value.kind === "method") {
+        return this.checkMethodOverridesOrShadowsMethod(entity, m.value);
+      }
+      return true;
+    })?.value;
   }
   findOverriddenOrShadowedOperatorInType(operator, typeMemberLookup) {
     return typeMemberLookup.getOperatorsByKind(operator.getOperatorKind()).find((o) => this.checkOperatorOverridesOrShadowsOperator(operator, o.value))?.value;
@@ -43443,10 +43553,11 @@ var OverriddenMember = class {
   }
 };
 var ShadowReason = /* @__PURE__ */ ((ShadowReason2) => {
-  ShadowReason2[ShadowReason2["BaseMemberCanNotBeOverridden"] = 0] = "BaseMemberCanNotBeOverridden";
-  ShadowReason2[ShadowReason2["NoOverrideModifier"] = 1] = "NoOverrideModifier";
-  ShadowReason2[ShadowReason2["NoOverrideModifierAndTypeOrReturnTypeMismatch"] = 2] = "NoOverrideModifierAndTypeOrReturnTypeMismatch";
-  ShadowReason2[ShadowReason2["TypeOrReturnTypeMismatch"] = 3] = "TypeOrReturnTypeMismatch";
+  ShadowReason2[ShadowReason2["BaseMemberHasDifferentKind"] = 0] = "BaseMemberHasDifferentKind";
+  ShadowReason2[ShadowReason2["BaseMemberCanNotBeOverridden"] = 1] = "BaseMemberCanNotBeOverridden";
+  ShadowReason2[ShadowReason2["NoOverrideModifier"] = 2] = "NoOverrideModifier";
+  ShadowReason2[ShadowReason2["NoOverrideModifierAndTypeOrReturnTypeMismatch"] = 3] = "NoOverrideModifierAndTypeOrReturnTypeMismatch";
+  ShadowReason2[ShadowReason2["TypeOrReturnTypeMismatch"] = 4] = "TypeOrReturnTypeMismatch";
   return ShadowReason2;
 })(ShadowReason || {});
 var ShadowedMemberInfo = class {
@@ -44088,7 +44199,7 @@ var TypeAssignabilityCheck = class {
   }
   isTypeAssignableTo(source, target) {
     const assignabilityFlags = this.getAssignabilityFlags(source, target);
-    return assignabilityFlags !== 1 /* NotAssignable */;
+    return (assignabilityFlags & 1 /* NotAssignable */) === 0;
   }
   getAssignabilityFlags(source, target) {
     source = unaliasType(source);
@@ -44113,7 +44224,7 @@ var TypeAssignabilityCheck = class {
       }
     }
     if (source.kind === "union") {
-      let result = 1 /* NotAssignable */;
+      let result = 0 /* None */;
       for (const type of source.unaliasedFlattenedTypes) {
         const constituentTypeResult = this.getAssignabilityFlags(type, target);
         if (constituentTypeResult === 1 /* NotAssignable */) {
@@ -44122,30 +44233,39 @@ var TypeAssignabilityCheck = class {
         }
         result |= constituentTypeResult;
       }
+      if (result === 0 /* None */) {
+        result = 2 /* Identity */;
+      }
       return result;
     }
     if (target.kind === "union") {
-      let result = 1 /* NotAssignable */;
+      let result = 0 /* None */;
       for (const type of target.unaliasedFlattenedTypes) {
         const constituentTypeResult = this.getAssignabilityFlags(source, type);
         if (this.areNewFlagsBetter(result, constituentTypeResult)) {
           result = constituentTypeResult;
         }
       }
+      if (result === 0 /* None */) {
+        result = 2 /* Identity */;
+      }
       return result;
     }
     if (source.kind === "intersection") {
-      let result = 1 /* NotAssignable */;
+      let result = 0 /* None */;
       for (const type of source.unaliasedFlattenedTypes) {
         const constituentTypeResult = this.getAssignabilityFlags(type, target);
         if (this.areNewFlagsBetter(result, constituentTypeResult)) {
           result = constituentTypeResult;
         }
       }
+      if (result === 0 /* None */) {
+        result = 2 /* Identity */;
+      }
       return result;
     }
     if (target.kind === "intersection") {
-      let result = 1 /* NotAssignable */;
+      let result = 0 /* None */;
       for (const type of target.unaliasedFlattenedTypes) {
         const constituentTypeResult = this.getAssignabilityFlags(source, type);
         if (constituentTypeResult === 1 /* NotAssignable */) {
@@ -44154,6 +44274,9 @@ var TypeAssignabilityCheck = class {
         }
         result |= constituentTypeResult;
       }
+      if (result === 0 /* None */) {
+        result = 2 /* Identity */;
+      }
       return result;
     }
     if (source.equals(this._analyzer.standardTypes.none) || target.equals(this._analyzer.standardTypes.none)) {
@@ -44239,7 +44362,7 @@ var TypeAssignabilityCheck = class {
     if (newFlags === currentFlags) {
       return false;
     }
-    if (currentFlags === 1 /* NotAssignable */) {
+    if (currentFlags === 0 /* None */ || currentFlags === 1 /* NotAssignable */) {
       return true;
     }
     const currentLowestScore = this.getLowestFlagsScore(currentFlags);
@@ -44253,9 +44376,11 @@ var TypeAssignabilityCheck = class {
     }
   }
   getLowestFlagsScore(flags) {
+    if (flags === 0 /* None */) {
+      return 0;
+    }
     let lowestScore = Number.MAX_SAFE_INTEGER;
-    let current = 1 /* First */;
-    while (current <= 16 /* Last */) {
+    for (let current = 1 /* First */; current <= 16 /* Last */; current <<= 1) {
       if ((flags & current) !== 0) {
         const score = this.getSingleFlagScore(current);
         if (score < lowestScore) {
@@ -44265,18 +44390,15 @@ var TypeAssignabilityCheck = class {
           break;
         }
       }
-      current <<= 1;
     }
     return lowestScore;
   }
   getFlagCount(flags) {
     let result = 0;
-    let current = 1 /* First */;
-    while (current <= 16 /* Last */) {
+    for (let current = 1 /* First */; current <= 16 /* Last */; current <<= 1) {
       if ((flags & current) !== 0) {
         result++;
       }
-      current <<= 1;
     }
     return result;
   }
@@ -46367,104 +46489,57 @@ var DiagnosticCollector = class _DiagnosticCollector {
     }
   }
   checkPackageMemberBodyPresence(entity, body, nodeForDiagnostics) {
-    const bodyRequirementReason = this.getPackageMemberBodyRequirementReason(entity);
-    switch (bodyRequirementReason) {
-      case 0 /* DoesNotRequireBecauseIsDeclaredInInterfacePackage */:
-        if (body !== void 0) {
-          this.addDiagnostic(this._analyzer.createNodeDiagnostic(
-            248 /* InterfacePackageMustNotContainImplementation */,
-            nodeForDiagnostics
-          ));
-        }
-        break;
-      case 1 /* DoesNotRequireBecauseHasBuiltIntoPlatformTag */:
-        if (body !== void 0) {
-          this.addDiagnostic(this._analyzer.createNodeDiagnostic(
-            254 /* DeclarationsMarkedWithBuiltIntoPlatformTagMustNotHaveBody */,
-            nodeForDiagnostics
-          ));
-        }
-        break;
-      case 2 /* RequiresBecauseIsRegularMember */:
-        if (body === void 0) {
-          this.addDiagnostic(this._analyzer.createNodeDiagnostic(250 /* BodyIsMissing */, nodeForDiagnostics));
-        }
-        break;
-      default:
-        Debug.never(bodyRequirementReason);
-    }
-  }
-  getPackageMemberBodyRequirementReason(entity) {
     if (this.isInterfacePackageFile) {
-      return 0 /* DoesNotRequireBecauseIsDeclaredInInterfacePackage */;
-    }
-    if (findTag(this._analyzer.wellKnownDeclarations.builtIntoPlatform, entity.getTags()) !== void 0) {
-      return 1 /* DoesNotRequireBecauseHasBuiltIntoPlatformTag */;
-    }
-    return 2 /* RequiresBecauseIsRegularMember */;
-  }
-  checkTypeMemberBodyPresence(entity, body, nodeForDiagnostics) {
-    const bodyRequirementReason = this.getTypeMemberBodyRequirementReason(entity);
-    switch (bodyRequirementReason) {
-      case 0 /* DoesNotRequireBecauseIsDeclaredInInterfacePackage */:
-        if (body !== void 0) {
-          this.addDiagnostic(this._analyzer.createNodeDiagnostic(
-            248 /* InterfacePackageMustNotContainImplementation */,
-            nodeForDiagnostics
-          ));
-        }
-        break;
-      case 1 /* DoesNotRequireBecauseIsAbstract */:
-        if (body !== void 0) {
-          this.addDiagnostic(this._analyzer.createNodeDiagnostic(
-            251 /* AbstractTypeMembersMustNotHaveBody */,
-            nodeForDiagnostics
-          ));
-        }
-        break;
-      case 3 /* DoesNotRequireBecauseHasBuiltIntoPlatformTag */:
-        if (body !== void 0) {
-          this.addDiagnostic(this._analyzer.createNodeDiagnostic(
-            254 /* DeclarationsMarkedWithBuiltIntoPlatformTagMustNotHaveBody */,
-            nodeForDiagnostics
-          ));
-        }
-        break;
-      case 2 /* DoesNotRequireBecauseIsAspectTypeMember */: {
-        if (body !== void 0) {
-          this.addDiagnostic(this._analyzer.createNodeDiagnostic(
-            252 /* MembersOfAspectTypeMustNotHaveBody */,
-            nodeForDiagnostics
-          ));
-        }
-        break;
+      if (body !== void 0) {
+        this.addDiagnostic(this._analyzer.createNodeDiagnostic(
+          248 /* InterfacePackageMustNotContainImplementation */,
+          nodeForDiagnostics
+        ));
+      }
+    } else if (findTag(this._analyzer.wellKnownDeclarations.builtIntoPlatform, entity.getTags()) !== void 0) {
+      if (body !== void 0) {
+        this.addDiagnostic(this._analyzer.createNodeDiagnostic(
+          254 /* DeclarationsMarkedWithBuiltIntoPlatformTagMustNotHaveBody */,
+          nodeForDiagnostics
+        ));
+      }
+    } else {
+      if (body === void 0) {
+        this.addDiagnostic(this._analyzer.createNodeDiagnostic(250 /* BodyIsMissing */, nodeForDiagnostics));
       }
-      case 4 /* RequiresBecauseIsBasicAspectTypeMember */:
-      case 5 /* RequiresBecauseIsHiddenAspectTypeMember */:
-      case 7 /* RequiresBecauseIsRegularMember */:
-      case 6 /* RequiresBecauseIsStaticMember */:
-        if (body === void 0) {
-          this.addDiagnostic(this._analyzer.createNodeDiagnostic(250 /* BodyIsMissing */, nodeForDiagnostics));
-        }
-        break;
-      default:
-        Debug.never(bodyRequirementReason);
     }
   }
-  getTypeMemberBodyRequirementReason(entity) {
+  checkTypeMemberBodyPresence(entity, body, nodeForDiagnostics) {
     if (this.isInterfacePackageFile) {
-      return 0 /* DoesNotRequireBecauseIsDeclaredInInterfacePackage */;
-    }
-    if (findTag(this._analyzer.wellKnownDeclarations.builtIntoPlatform, entity.getTags()) !== void 0) {
-      return 3 /* DoesNotRequireBecauseHasBuiltIntoPlatformTag */;
-    }
-    if (TypeMemberEntity.isStatic(entity)) {
-      return 6 /* RequiresBecauseIsStaticMember */;
-    }
-    if (entity.markedAbstract()) {
-      return 1 /* DoesNotRequireBecauseIsAbstract */;
+      if (body !== void 0) {
+        this.addDiagnostic(this._analyzer.createNodeDiagnostic(
+          248 /* InterfacePackageMustNotContainImplementation */,
+          nodeForDiagnostics
+        ));
+      }
+    } else if (findTag(this._analyzer.wellKnownDeclarations.builtIntoPlatform, entity.getTags()) !== void 0) {
+      if (body !== void 0) {
+        this.addDiagnostic(this._analyzer.createNodeDiagnostic(
+          254 /* DeclarationsMarkedWithBuiltIntoPlatformTagMustNotHaveBody */,
+          nodeForDiagnostics
+        ));
+      }
+    } else if (TypeMemberEntity.isStatic(entity)) {
+      if (body === void 0) {
+        this.addDiagnostic(this._analyzer.createNodeDiagnostic(250 /* BodyIsMissing */, nodeForDiagnostics));
+      }
+    } else if (entity.markedAbstract()) {
+      if (body !== void 0) {
+        this.addDiagnostic(this._analyzer.createNodeDiagnostic(
+          251 /* AbstractTypeMembersMustNotHaveBody */,
+          nodeForDiagnostics
+        ));
+      }
+    } else {
+      if (body === void 0) {
+        this.addDiagnostic(this._analyzer.createNodeDiagnostic(250 /* BodyIsMissing */, nodeForDiagnostics));
+      }
     }
-    return 7 /* RequiresBecauseIsRegularMember */;
   }
   // TODO: учесть константы времени компиляции.
   // private validateVariantInitializer(expression: tree.Expression): void {
@@ -47195,7 +47270,15 @@ var DiagnosticCollector = class _DiagnosticCollector {
         continue;
       }
       switch (shadowedMember.shadowReason) {
-        case 0 /* BaseMemberCanNotBeOverridden */: {
+        case 0 /* BaseMemberHasDifferentKind */: {
+          this.addDiagnostic(this._analyzer.createNodeDiagnostic(
+            338 /* DeclarationConflictsWithBaseTypeMember0 */,
+            nodeForDiagnostic,
+            [this._displayService.displayTypeMember(shadowedMember.value)]
+          ));
+          break;
+        }
+        case 1 /* BaseMemberCanNotBeOverridden */: {
           if (entity.isOverride()) {
             this.addDiagnostic(this._analyzer.createNodeDiagnostic(
               340 /* DeclarationConflictsWithBaseTypeMember0ThisMemberCanNotBeOverridden */,
@@ -47211,7 +47294,7 @@ var DiagnosticCollector = class _DiagnosticCollector {
           }
           break;
         }
-        case 1 /* NoOverrideModifier */: {
+        case 2 /* NoOverrideModifier */: {
           this.addDiagnostic(this._analyzer.createNodeDiagnostic(
             339 /* DeclarationConflictsWithBaseTypeMember0AddOverrideModifier */,
             nodeForDiagnostic,
@@ -47219,7 +47302,7 @@ var DiagnosticCollector = class _DiagnosticCollector {
           ));
           break;
         }
-        case 3 /* TypeOrReturnTypeMismatch */: {
+        case 4 /* TypeOrReturnTypeMismatch */: {
           const diagnosticCode = entity.kind === 0 /* Variable */ ? 341 /* DeclarationConflictsWithBaseTypeMember0ToOverrideTypeMustBeAssignableTo1 */ : 342 /* DeclarationConflictsWithBaseTypeMember0ToOverrideReturnTypeMustBeAssignableTo1 */;
           const type = this._analyzer.overriddenMember.getMemberTypeOrReturnType(shadowedMember.value);
           this.addDiagnostic(this._analyzer.createNodeDiagnostic(
@@ -47229,7 +47312,7 @@ var DiagnosticCollector = class _DiagnosticCollector {
           ));
           break;
         }
-        case 2 /* NoOverrideModifierAndTypeOrReturnTypeMismatch */:
+        case 3 /* NoOverrideModifierAndTypeOrReturnTypeMismatch */:
           this.addDiagnostic(this._analyzer.createNodeDiagnostic(
             338 /* DeclarationConflictsWithBaseTypeMember0 */,
             nodeForDiagnostic,
@@ -53032,22 +53115,22 @@ var MethodDeclaration3 = class _MethodDeclaration {
   }
 };
 var FieldAccessExpression = class _FieldAccessExpression {
-  constructor(expression, isOptionalAccess, variable, accessKind, ifComputedThenKey, sourceLocation, options = FieldAccessExpressionEmitOptions.default()) {
+  constructor(expression, isOptionalAccess, field, accessKind, ifComputedThenKey, sourceLocation, options = FieldAccessExpressionEmitOptions.default()) {
     this.expression = expression;
     this.isOptionalAccess = isOptionalAccess;
-    this.variable = variable;
+    this.field = field;
     this.accessKind = accessKind;
     this.ifComputedThenKey = ifComputedThenKey;
     this.sourceLocation = sourceLocation;
     this.options = options;
     this.kind = 69 /* FieldAccessExpression */;
   }
-  static get(expression, isOptionalAccess, variable, ifComputedThenKey, sourceLocation) {
+  static get(expression, isOptionalAccess, field, ifComputedThenKey, sourceLocation) {
     let accessedVariable;
-    if (variable instanceof AccessedVariable) {
-      accessedVariable = variable;
+    if (field instanceof AccessedVariable) {
+      accessedVariable = field;
     } else {
-      accessedVariable = AccessedVariable.fromEntity(variable);
+      accessedVariable = AccessedVariable.fromEntity(field);
     }
     return new _FieldAccessExpression(
       expression,
@@ -53058,12 +53141,12 @@ var FieldAccessExpression = class _FieldAccessExpression {
       sourceLocation
     );
   }
-  static set(expression, isOptionalAccess, variable, ifComputedThenKey, sourceLocation) {
+  static set(expression, isOptionalAccess, field, ifComputedThenKey, sourceLocation) {
     let accessedVariable;
-    if (variable instanceof AccessedVariable) {
-      accessedVariable = variable;
+    if (field instanceof AccessedVariable) {
+      accessedVariable = field;
     } else {
-      accessedVariable = AccessedVariable.fromEntity(variable);
+      accessedVariable = AccessedVariable.fromEntity(field);
     }
     return new _FieldAccessExpression(
       expression,
@@ -53078,7 +53161,7 @@ var FieldAccessExpression = class _FieldAccessExpression {
     return new _FieldAccessExpression(
       this.expression.clone(),
       this.isOptionalAccess,
-      this.variable,
+      this.field,
       this.accessKind,
       this.ifComputedThenKey?.clone(),
       this.sourceLocation,
@@ -53394,7 +53477,7 @@ var TypeUtils2 = class {
       case 66 /* FunctionAccessExpression */:
         return this._ectx.standardTypes.func;
       case 69 /* FieldAccessExpression */:
-        return expression.variable.type;
+        return expression.field.type;
       case 70 /* MethodAccessExpression */:
         return this._ectx.standardTypes.func;
       case 71 /* ConstructorCallExpression */:
@@ -55774,22 +55857,29 @@ var GeneralLoweringContext = class {
   generateId() {
     return this._id++;
   }
-  createInitializedTemporaryVariable(initializer, containingPackage, tempVariables) {
-    const tempVariable = this.createUniqueLocalVariableEntity(
-      containingPackage,
-      this.ectx.type.ofExpression(initializer)
-    );
-    tempVariables?.push(tempVariable);
-    const tempVariableAssignment = new AssignmentExpression(
-      VariableAccessExpression.get(tempVariable),
-      0 /* Equals */,
-      initializer,
-      void 0,
-      void 0,
-      new AssignmentEmitOptions(false, false, false)
-    );
-    const tempVariableGetAccess = VariableAccessExpression.get(tempVariable);
-    return [tempVariable, tempVariableAssignment, tempVariableGetAccess];
+  createCachingTemporaryVariable(initializer, containingPackage, tempVariables) {
+    let tempVariable;
+    let assignment;
+    let access;
+    if (this.isExpressionThatDoesNotNeedToBeCached(initializer)) {
+      access = initializer;
+    } else {
+      tempVariable = this.createUniqueLocalVariableEntity(
+        containingPackage,
+        this.ectx.type.ofExpression(initializer)
+      );
+      tempVariables?.push(tempVariable);
+      assignment = new AssignmentExpression(
+        VariableAccessExpression.get(tempVariable),
+        0 /* Equals */,
+        initializer,
+        void 0,
+        void 0,
+        new AssignmentEmitOptions(false, false, false)
+      );
+      access = VariableAccessExpression.get(tempVariable);
+    }
+    return [tempVariable, assignment, access];
   }
   getBinaryExpressionOperatorFromAssignmentOperator(operator) {
     switch (operator) {
@@ -56015,17 +56105,29 @@ var GeneralLoweringContext = class {
         return false;
     }
   }
+  isPossiblyCastedBaseExpression(node) {
+    return this.ifPossiblyCastedBaseExpressionThenExpression(node) !== void 0;
+  }
+  ifPossiblyCastedBaseExpressionThenExpression(node) {
+    if (node.kind === 0 /* AsExpression */) {
+      node = node.expression;
+    }
+    if (node.kind === 89 /* BaseExpression */) {
+      return node;
+    }
+    return void 0;
+  }
   createMemberAccessWithNullCheck(receiver, createMemberAccess, tempVariables, containingPackage) {
     let result;
     if (this.isOptionalChaining(receiver)) {
-      const [, tempVariableAssignment, tempVariableAccess] = this.createInitializedTemporaryVariable(
+      const [, tempVariableAssignment, tempVariableAccess] = this.createCachingTemporaryVariable(
         receiver,
         containingPackage,
         tempVariables
       );
       const substitutionMemberAccess = createMemberAccess(tempVariableAccess);
       const isEmptyExpression = new BinaryExpression3(
-        tempVariableAssignment,
+        tempVariableAssignment ?? tempVariableAccess,
         5 /* Equals */,
         new NoneLiteral(void 0),
         this.ectx.standardTypes.yesNo,
@@ -56045,6 +56147,23 @@ var GeneralLoweringContext = class {
     }
     return result;
   }
+  isExpressionThatDoesNotNeedToBeCached(node) {
+    switch (node.kind) {
+      case 58 /* ThisExpression */:
+      case 89 /* BaseExpression */:
+      case 64 /* TypeAccessExpression */:
+      case 6 /* BooleanLiteral */:
+      case 31 /* IntegerLiteral */:
+      case 37 /* NumericLiteral */:
+        return true;
+      case 65 /* VariableAccessExpression */: {
+        const entity = node.variable.entity;
+        return !entity.isPackageMember && entity.ifTypeMemberThenContainingType === void 0;
+      }
+      default:
+        return false;
+    }
+  }
   createUniqueLocalVariableEntity(containingPackage, type) {
     const name = EmitPhaseName.ofTempVariable(containingPackage.locale, this.generateId());
     return new IntrinsicVariableEntity(name, type, containingPackage);
@@ -56087,8 +56206,8 @@ var ExecutableCodeLowering = class {
     this._ctx = _ctx;
     this._packageEntity = _packageEntity;
   }
-  createInitializedTemporaryVariable(initializer, tempVariables) {
-    return this._ctx.createInitializedTemporaryVariable(initializer, this._packageEntity, tempVariables);
+  createCachingTemporaryVariable(initializer, tempVariables) {
+    return this._ctx.createCachingTemporaryVariable(initializer, this._packageEntity, tempVariables);
   }
   createMemberAccessWithNullCheck(receiver, tempVariables, createMemberAccess) {
     return this._ctx.createMemberAccessWithNullCheck(receiver, createMemberAccess, tempVariables, this._packageEntity);
@@ -56898,7 +57017,7 @@ var AliasTypeAndExtensionMembersAccessLowering = class extends ExecutableCodeLow
     return void 0;
   }
   tryLowerFieldAccessExpression(node) {
-    const entity = node.variable.entity;
+    const entity = node.field.entity;
     if (entity.getter?.details.isAliasTypeOrExtensionMemberThatRequiresLowering === true) {
       const { expression, tempVariables } = this.lowerComputedVariableGetAccess(node);
       return replaceExpression(expression, tempVariables);
@@ -56907,7 +57026,7 @@ var AliasTypeAndExtensionMembersAccessLowering = class extends ExecutableCodeLow
   }
   tryLowerAssignmentStatement(node) {
     if (node.left.kind === 69 /* FieldAccessExpression */) {
-      const entity = node.left.variable.entity;
+      const entity = node.left.field.entity;
       if (entity.setter?.details.isAliasTypeOrExtensionMemberThatRequiresLowering === true) {
         const { statement, tempVariables } = this.lowerComputedVariableSetAccess(node);
         return replaceStatement(statement, tempVariables);
@@ -56920,12 +57039,16 @@ var AliasTypeAndExtensionMembersAccessLowering = class extends ExecutableCodeLow
     Debug.assert(callee.kind === 70 /* MethodAccessExpression */);
     const args = this._ctx.getOrderedArguments(node.args);
     const tempVariables = new Array();
+    let receiver = callee.expression;
+    if (this._ctx.isPossiblyCastedBaseExpression(receiver)) {
+      receiver = new ThisExpression(this._ctx.ectx.type.ofExpression(receiver), receiver.sourceLocation);
+    }
     const expression = this.createMemberAccessWithNullCheck(
-      callee.expression,
+      receiver,
       tempVariables,
-      (receiver) => this.createCallOfMethodWithExplicitReceiver(
+      (nonEmptyReceiver) => this.createCallOfMethodWithExplicitReceiver(
         callee.method.entity,
-        receiver,
+        nonEmptyReceiver,
         args,
         node.returnType
       )
@@ -56958,18 +57081,22 @@ var AliasTypeAndExtensionMembersAccessLowering = class extends ExecutableCodeLow
   }
   lowerComputedVariableGetAccess(node) {
     Debug.assert(node.accessKind === 0 /* Get */);
-    const getter = node.variable.entity.getter;
+    const getter = node.field.entity.getter;
     Debug.assertNotNull(getter);
     const args = new OrderedArguments([], false);
     const tempVariables = new Array();
+    let receiver = node.expression;
+    if (this._ctx.isPossiblyCastedBaseExpression(receiver)) {
+      receiver = new ThisExpression(this._ctx.ectx.type.ofExpression(receiver), receiver.sourceLocation);
+    }
     const expression = this.createMemberAccessWithNullCheck(
-      node.expression,
+      receiver,
       tempVariables,
-      (receiver) => this.createCallOfMethodWithExplicitReceiver(
+      (nonEmptyReceiver) => this.createCallOfMethodWithExplicitReceiver(
         getter,
-        receiver,
+        nonEmptyReceiver,
         args,
-        node.variable.type
+        node.field.type
       )
     );
     return { expression, tempVariables };
@@ -57017,26 +57144,34 @@ var AliasTypeAndExtensionMembersAccessLowering = class extends ExecutableCodeLow
     );
   }
   lowerSimpleAssignmentToComputedVariable(left, value) {
-    const setter = left.variable.entity.setter;
+    const setter = left.field.entity.setter;
     Debug.assertNotNull(setter);
     const args = new OrderedArguments([value], false);
+    let receiver = left.expression;
+    if (this._ctx.isPossiblyCastedBaseExpression(receiver)) {
+      receiver = new ThisExpression(this._ctx.ectx.type.ofExpression(receiver), receiver.sourceLocation);
+    }
     const callExpression2 = this.createCallOfMethodWithExplicitReceiver(
       setter,
-      left.expression,
+      receiver,
       args,
       this._ctx.ectx.standardTypes.none
     );
     return new ExpressionStatement3(callExpression2, left.sourceLocation);
   }
   lowerCompoundAssignmentToComputedVariable(left, operatorKind, value, operator) {
-    const setter = left.variable.entity.setter;
+    const setter = left.field.entity.setter;
     Debug.assertNotNull(setter);
     const tempVariables = new Array();
-    const [, receiverTempAssignment, receiverTempAccess] = this.createInitializedTemporaryVariable(
-      left.expression,
+    let receiver = left.expression;
+    if (this._ctx.isPossiblyCastedBaseExpression(receiver)) {
+      receiver = new ThisExpression(this._ctx.ectx.type.ofExpression(receiver), receiver.sourceLocation);
+    }
+    const [, receiverTempAssignment, receiverTempAccess] = this.createCachingTemporaryVariable(
+      receiver,
       tempVariables
     );
-    const variableGetAccess = FieldAccessExpression.get(receiverTempAccess, false, left.variable, void 0);
+    const variableGetAccess = FieldAccessExpression.get(receiverTempAccess, false, left.field, void 0);
     const binaryOperator = this._ctx.getBinaryExpressionOperatorFromAssignmentOperator(operatorKind);
     const newValue = new BinaryExpression3(
       variableGetAccess,
@@ -57049,7 +57184,7 @@ var AliasTypeAndExtensionMembersAccessLowering = class extends ExecutableCodeLow
     const args = new OrderedArguments([newValue], false);
     const callExpression2 = this.createCallOfMethodWithExplicitReceiver(
       setter,
-      receiverTempAssignment,
+      receiverTempAssignment ?? receiverTempAccess,
       args,
       this._ctx.ectx.standardTypes.none
     );
@@ -57656,17 +57791,17 @@ var IndexedAccessExpressionLowering = class extends ExecutableCodeLowering {
     Debug.assert(node.left.kind === 30 /* IndexedAccessExpression */);
     Debug.assert(node.left.access.kind === 2 /* GetSet */);
     const tempVariables = [];
-    const [, receiverTempAssignment, receiverTempAccess] = this.createInitializedTemporaryVariable(
+    const [, receiverTempAssignment, receiverTempAccess] = this.createCachingTemporaryVariable(
       node.left.expression,
       tempVariables
     );
     const args = this._ctx.getOrderedArguments(node.left.args);
     const [argumentTempAssignments, argumentTempAccesses] = Query.from(args.values).map((a) => {
-      const [, argumentTempAssignment, argumentTempAccess] = this.createInitializedTemporaryVariable(
+      const [, argumentTempAssignment, argumentTempAccess] = this.createCachingTemporaryVariable(
         a,
         tempVariables
       );
-      return [argumentTempAssignment, argumentTempAccess];
+      return [argumentTempAssignment ?? argumentTempAccess, argumentTempAccess];
     }).unzip();
     const access = { kind: 0 /* Get */, getAccessor: node.left.access.getAccessor };
     const indexerGetAccess = new IndexedAccessExpression3(
@@ -57686,7 +57821,7 @@ var IndexedAccessExpressionLowering = class extends ExecutableCodeLowering {
       void 0
     );
     const methodAccess = new MethodAccessExpression(
-      receiverTempAssignment,
+      receiverTempAssignment ?? receiverTempAccess,
       false,
       node.left.access.setAccessor,
       true,
@@ -57787,7 +57922,7 @@ var DereferenceExpressionLowering = class extends ExecutableCodeLowering {
     Debug.assert(node.left.kind === 88 /* DereferenceExpression */);
     Debug.assert(node.left.access.kind === 2 /* GetSet */);
     const tempVariables = [];
-    const [, receiverTempAssignment, receiverTempAccess] = this.createInitializedTemporaryVariable(
+    const [, receiverTempAssignment, receiverTempAccess] = this.createCachingTemporaryVariable(
       node.left.expression,
       tempVariables
     );
@@ -57808,7 +57943,7 @@ var DereferenceExpressionLowering = class extends ExecutableCodeLowering {
       void 0
     );
     const methodAccess = new MethodAccessExpression(
-      receiverTempAssignment,
+      receiverTempAssignment ?? receiverTempAccess,
       false,
       node.left.access.setAccessor,
       true,
@@ -57862,7 +57997,16 @@ var FunctionObjectLowering = class _FunctionObjectLowering extends ExecutableCod
   //        recTmp = rec, recTmp === undefined ? undefined : (opTmp = (...args) => { return recTmp.op(...args) }, opTmp._ctx = recTmp, opTmp)
   lowerInstanceMethodAccess(node) {
     const tempVariables = new Array();
-    const [, receiverTempAssignment, receiverTempGetAccess] = this.createInitializedTemporaryVariable(node.expression, tempVariables);
+    const receiverIfBaseExpression = this._ctx.ifPossiblyCastedBaseExpressionThenExpression(node.expression);
+    let receiverTempAssignment = void 0;
+    let receiverTempGetAccess;
+    if (receiverIfBaseExpression === void 0) {
+      const parts = this.createCachingTemporaryVariable(node.expression, tempVariables);
+      receiverTempAssignment = parts[1];
+      receiverTempGetAccess = parts[2];
+    } else {
+      receiverTempGetAccess = receiverIfBaseExpression;
+    }
     const methodAccess = new MethodAccessExpression(
       receiverTempGetAccess,
       false,
@@ -57889,7 +58033,7 @@ var FunctionObjectLowering = class _FunctionObjectLowering extends ExecutableCod
       node.method.returnType,
       void 0
     );
-    const [, boundMethodTempAssignment, boundMethodTempGetAccess] = this.createInitializedTemporaryVariable(functionLiteral, tempVariables);
+    const [, boundMethodTempAssignment, boundMethodTempGetAccess] = this.createCachingTemporaryVariable(functionLiteral, tempVariables);
     let contextFieldAssignment;
     if (!node.method.entity.details.isStatic) {
       const contextFieldSetAccess = new JsPropertyAccessExpression(
@@ -57899,10 +58043,16 @@ var FunctionObjectLowering = class _FunctionObjectLowering extends ExecutableCod
         this._ctx.ectx.standardTypes.refObject,
         void 0
       );
+      let context;
+      if (receiverIfBaseExpression === void 0) {
+        context = receiverTempGetAccess;
+      } else {
+        context = new ThisExpression(this._ctx.ectx.type.ofExpression(receiverIfBaseExpression), void 0);
+      }
       contextFieldAssignment = new AssignmentExpression(
         contextFieldSetAccess,
         0 /* Equals */,
-        receiverTempGetAccess,
+        context,
         void 0,
         void 0
       );
@@ -57918,7 +58068,10 @@ var FunctionObjectLowering = class _FunctionObjectLowering extends ExecutableCod
         void 0
       );
       const firstExpression = new NoneLiteral(void 0);
-      const expressions = [boundMethodTempAssignment];
+      const expressions = new Array();
+      if (boundMethodTempAssignment !== void 0) {
+        expressions.push(boundMethodTempAssignment);
+      }
       if (contextFieldAssignment !== void 0) {
         expressions.push(contextFieldAssignment);
       }
@@ -57931,14 +58084,25 @@ var FunctionObjectLowering = class _FunctionObjectLowering extends ExecutableCod
         this._ctx.ectx.type.ofExpression(node),
         void 0
       );
-      resultExpression = new CommaExpression([receiverTempAssignment, ternaryExpression], node.sourceLocation);
+      const resultExpressions = new Array();
+      if (receiverTempAssignment !== void 0) {
+        resultExpressions.push(receiverTempAssignment);
+      }
+      resultExpressions.push(ternaryExpression);
+      resultExpression = new CommaExpression(resultExpressions, node.sourceLocation);
     } else {
-      const expressions = [receiverTempAssignment, boundMethodTempAssignment];
+      const resultExpressions = new Array();
+      if (receiverTempAssignment !== void 0) {
+        resultExpressions.push(receiverTempAssignment);
+      }
+      if (boundMethodTempAssignment !== void 0) {
+        resultExpressions.push(boundMethodTempAssignment);
+      }
       if (contextFieldAssignment !== void 0) {
-        expressions.push(contextFieldAssignment);
+        resultExpressions.push(contextFieldAssignment);
       }
-      expressions.push(boundMethodTempGetAccess);
-      resultExpression = new CommaExpression(expressions, node.sourceLocation);
+      resultExpressions.push(boundMethodTempGetAccess);
+      resultExpression = new CommaExpression(resultExpressions, node.sourceLocation);
     }
     return { expression: resultExpression, tempVariables };
   }
@@ -58129,13 +58293,13 @@ var UsagesLowering = class _UsagesLowering extends ExecutableCodeLowering {
           return result;
         }
         const nameKeySymbolDeclaration = this.ifTypeMemberHasComputedNameThenSymbolDeclaration(
-          node.variable.entity,
+          node.field.entity,
           false
         );
         if (nameKeySymbolDeclaration !== void 0 && !node.options.forceUseNonComputedName) {
           node.ifComputedThenKey = this._ctx.createKeyForComputedNameWithSymbolKey(nameKeySymbolDeclaration);
         }
-        if (node.variable.entity.ifTypeMemberThenContainingType !== void 0 && this._ctx.ectx.isAspectTypeEntity(node.variable.entity.ifTypeMemberThenContainingType) && node.variable.entity.details.isStatic) {
+        if (node.field.entity.ifTypeMemberThenContainingType !== void 0 && this._ctx.ectx.isAspectTypeEntity(node.field.entity.ifTypeMemberThenContainingType) && node.field.entity.details.isStatic) {
           this.lowerStaticAliasFieldAccess(node);
         }
         return preserveExpression();
@@ -58336,7 +58500,7 @@ var UsagesLowering = class _UsagesLowering extends ExecutableCodeLowering {
   // Статические члены аспектов не добавляются в тип, который реализует аспект. Поэтому если доступ к статическому полю
   // или методу осуществляется через производный тип, его необходимо заменить на доступ через тип-аспект.
   lowerStaticAliasFieldAccess(node) {
-    const containingType = node.variable.entity.ifTypeMemberThenContainingType;
+    const containingType = node.field.entity.ifTypeMemberThenContainingType;
     Debug.assertNotNull(containingType);
     if (!(node.expression.kind === 64 /* TypeAccessExpression */ && node.expression.entity === containingType)) {
       node.expression = new TypeAccessExpression(containingType, void 0);
@@ -58443,29 +58607,29 @@ var OperatorsUsageLowering = class extends ExecutableCodeLowering {
         leftExpressionGetAccess = VariableAccessExpression.get(left.variable);
         break;
       case 69 /* FieldAccessExpression */: {
-        const [, receiverTempAssignment, receiverTempGetAccess] = this.createInitializedTemporaryVariable(
+        const [, receiverTempAssignment, receiverTempGetAccess] = this.createCachingTemporaryVariable(
           left.expression,
           tempVariables
         );
         leftExpressionSetAccess = FieldAccessExpression.set(
-          receiverTempAssignment,
+          receiverTempAssignment ?? receiverTempGetAccess,
           false,
-          left.variable
+          left.field
         );
         leftExpressionGetAccess = FieldAccessExpression.get(
           receiverTempGetAccess,
           false,
-          left.variable
+          left.field
         );
         break;
       }
       case 83 /* JsPropertyAccessExpression */: {
-        const [, receiverTempAssignment, receiverTempGetAccess] = this.createInitializedTemporaryVariable(
+        const [, receiverTempAssignment, receiverTempGetAccess] = this.createCachingTemporaryVariable(
           left.expression,
           tempVariables
         );
         leftExpressionSetAccess = new JsPropertyAccessExpression(
-          receiverTempAssignment,
+          receiverTempAssignment ?? receiverTempGetAccess,
           false,
           left.name,
           left.type,
@@ -58481,12 +58645,12 @@ var OperatorsUsageLowering = class extends ExecutableCodeLowering {
         break;
       }
       case 77 /* JsIndexedAccessExpression */: {
-        const [, receiverTempAssignment, receiverTempGetAccess] = this.createInitializedTemporaryVariable(left.expression, tempVariables);
-        const [, argumentTempAssignment, argumentTempGetAccess] = this.createInitializedTemporaryVariable(left.expression, tempVariables);
+        const [, receiverTempAssignment, receiverTempGetAccess] = this.createCachingTemporaryVariable(left.expression, tempVariables);
+        const [, argumentTempAssignment, argumentTempGetAccess] = this.createCachingTemporaryVariable(left.expression, tempVariables);
         leftExpressionSetAccess = new JsIndexedAccessExpression(
-          receiverTempAssignment,
+          receiverTempAssignment ?? receiverTempGetAccess,
           false,
-          argumentTempAssignment,
+          argumentTempAssignment ?? argumentTempGetAccess,
           left.type,
           void 0
         );
@@ -58506,17 +58670,17 @@ var OperatorsUsageLowering = class extends ExecutableCodeLowering {
       }
       case 30 /* IndexedAccessExpression */: {
         Debug.assert(left.access.kind === 2 /* GetSet */);
-        const [, receiverTempAssignment, receiverTempGetAccess] = this.createInitializedTemporaryVariable(
+        const [, receiverTempAssignment, receiverTempGetAccess] = this.createCachingTemporaryVariable(
           left.expression,
           tempVariables
         );
         const args = this._ctx.getOrderedArguments(left.args);
         const [argumentTempAssignments, argumentTempAccesses] = Query.from(args.values).map((a) => {
-          const [, argumentTempAssignment, argumentTempAccess] = this.createInitializedTemporaryVariable(
+          const [, argumentTempAssignment, argumentTempAccess] = this.createCachingTemporaryVariable(
             a,
             tempVariables
           );
-          return [argumentTempAssignment, argumentTempAccess];
+          return [argumentTempAssignment ?? argumentTempAccess, argumentTempAccess];
         }).unzip();
         const getAccess = { kind: 0 /* Get */, getAccessor: left.access.getAccessor };
         leftExpressionGetAccess = new IndexedAccessExpression3(
@@ -58528,7 +58692,7 @@ var OperatorsUsageLowering = class extends ExecutableCodeLowering {
         );
         const setAccess = { kind: 1 /* Set */, setAccessor: left.access.setAccessor };
         leftExpressionSetAccess = new IndexedAccessExpression3(
-          receiverTempAssignment,
+          receiverTempAssignment ?? receiverTempGetAccess,
           false,
           new OrderedArguments(argumentTempAssignments, args.isLastArgumentSpreading),
           setAccess,
@@ -58559,8 +58723,8 @@ var ProxiedVariableAccessLowering = class extends ExecutableCodeLowering {
     this._proxyVariableByOriginal = proxyVariableByOriginal;
   }
   tryLowerFieldAccessExpression(node) {
-    if (node.variable.entity.details.isProxiedField !== void 0) {
-      const proxyVariable = this.findProxyVariable(node.variable.entity);
+    if (node.field.entity.details.isProxiedField !== void 0) {
+      const proxyVariable = this.findProxyVariable(node.field.entity);
       if (proxyVariable !== void 0) {
         const { expression, tempVariables } = this.lowerProxiedFieldRead(node, proxyVariable);
         return replaceExpression(expression, tempVariables);
@@ -58569,8 +58733,8 @@ var ProxiedVariableAccessLowering = class extends ExecutableCodeLowering {
     return void 0;
   }
   tryLowerAssignmentStatement(node) {
-    if (node.left.kind === 69 /* FieldAccessExpression */ && node.left.variable.entity.details.isProxiedField !== void 0) {
-      const proxyVariable = this.findProxyVariable(node.left.variable.entity);
+    if (node.left.kind === 69 /* FieldAccessExpression */ && node.left.field.entity.details.isProxiedField !== void 0) {
+      const proxyVariable = this.findProxyVariable(node.left.field.entity);
       if (proxyVariable !== void 0) {
         const { statement, tempVariables } = this.lowerProxiedFieldAssignment(node, proxyVariable);
         return replaceStatement(statement, tempVariables);
@@ -58592,9 +58756,9 @@ var ProxiedVariableAccessLowering = class extends ExecutableCodeLowering {
   // обВрем = об, обВрем.прокси_поле.записать(значение, обВрем, "поле", new ПутьКСинтаксическомуУзлу("..."))
   lowerProxiedFieldAssignment(node, proxyVariable) {
     Debug.assert(node.left.kind === 69 /* FieldAccessExpression */);
-    const proxiedVariableEntity = node.left.variable.entity;
+    const proxiedVariableEntity = node.left.field.entity;
     const tempVariables = new Array();
-    const [, receiverTempAssignment, receiverTempGetAccess] = this.createInitializedTemporaryVariable(node.left.expression, tempVariables);
+    const [, receiverTempAssignment, receiverTempGetAccess] = this.createCachingTemporaryVariable(node.left.expression, tempVariables);
     Debug.assert(node.left.isOptionalAccess === false, "\u0414\u043E\u0441\u0442\u0443\u043F \u043A \u043F\u043E\u043B\u044E \u0447\u0435\u0440\u0435\u0437 ?. \u0432 \u043B\u0435\u0432\u043E\u0439 \u0447\u0430\u0441\u0442\u0438 \u043F\u0440\u0438\u0441\u0432\u0430\u0438\u0432\u0430\u043D\u0438\u044F \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F.");
     const writeMethodAccess = new MethodAccessExpression(
       FieldAccessExpression.get(
@@ -58623,7 +58787,12 @@ var ProxiedVariableAccessLowering = class extends ExecutableCodeLowering {
       this._ctx.ectx.type.ofExpression(node.right),
       void 0
     );
-    const commaExpression = new CommaExpression([receiverTempAssignment, writeMethodCall], void 0);
+    const expressions = new Array();
+    if (receiverTempAssignment !== void 0) {
+      expressions.push(receiverTempAssignment);
+    }
+    expressions.push(writeMethodCall);
+    const commaExpression = new CommaExpression(expressions, void 0);
     const statement = new ExpressionStatement3(commaExpression, void 0);
     return { statement, tempVariables };
   }
@@ -58633,8 +58802,8 @@ var ProxiedVariableAccessLowering = class extends ExecutableCodeLowering {
   // обВрем = об, обВрем.прокси_поле.прочитать(обВрем, "поле", new ПутьКСинтаксическомуУзлу("..."))
   lowerProxiedFieldRead(node, proxyVariable) {
     const tempVariables = new Array();
-    const [, receiverTempAssignment, receiverTempGetAccess] = this.createInitializedTemporaryVariable(node.expression, tempVariables);
-    const proxiedVariableEntity = node.variable.entity;
+    const [, receiverTempAssignment, receiverTempGetAccess] = this.createCachingTemporaryVariable(node.expression, tempVariables);
+    const proxiedVariableEntity = node.field.entity;
     const readMethodAccess = new MethodAccessExpression(
       FieldAccessExpression.get(
         receiverTempGetAccess,
@@ -58661,7 +58830,12 @@ var ProxiedVariableAccessLowering = class extends ExecutableCodeLowering {
       this._ctx.ectx.type.ofExpression(node),
       void 0
     );
-    const expression = new CommaExpression([receiverTempAssignment, readMethodCall], void 0);
+    const expressions = new Array();
+    if (receiverTempAssignment !== void 0) {
+      expressions.push(receiverTempAssignment);
+    }
+    expressions.push(readMethodCall);
+    const expression = new CommaExpression(expressions, void 0);
     return { expression, tempVariables };
   }
   createAccessLocation(node) {
@@ -58709,13 +58883,13 @@ var ReferenceExpressionLowering = class extends ExecutableCodeLowering {
     const access = referencedExpression.access;
     Debug.assert(isGetOrGetSet(access));
     const tempVariables = new Array();
-    const [, receiverAssignment, receiverGetAccess] = this.createInitializedTemporaryVariable(referencedExpression.expression, tempVariables);
-    const temporaryVariableAssignments = [receiverAssignment];
+    const [, receiverAssignment, receiverGetAccess] = this.createCachingTemporaryVariable(referencedExpression.expression, tempVariables);
+    const temporaryVariableAssignments = [receiverAssignment ?? receiverGetAccess];
     const args = this._ctx.getOrderedArguments(referencedExpression.args);
     const argumentGetAccesses = [];
     for (const argument of args.values) {
-      const [, argumentAssignment, argumentGetAccess] = this.createInitializedTemporaryVariable(argument, tempVariables);
-      temporaryVariableAssignments.push(argumentAssignment);
+      const [, argumentAssignment, argumentGetAccess] = this.createCachingTemporaryVariable(argument, tempVariables);
+      temporaryVariableAssignments.push(argumentAssignment ?? argumentGetAccess);
       argumentGetAccesses.push(argumentGetAccess);
     }
     const getAccess = { kind: 0 /* Get */, getAccessor: access.getAccessor };
@@ -58755,11 +58929,11 @@ var ReferenceExpressionLowering = class extends ExecutableCodeLowering {
   }
   lowerFieldAccessExpressionReference(referencedExpression, sourceLocation) {
     const tempVariables = new Array();
-    const [, receiverAssignment, receiverGetAccess] = this.createInitializedTemporaryVariable(referencedExpression.expression, tempVariables);
+    const [, receiverAssignment, receiverGetAccess] = this.createCachingTemporaryVariable(referencedExpression.expression, tempVariables);
     const variableGetAccess = FieldAccessExpression.get(
       receiverGetAccess,
       referencedExpression.isOptionalAccess,
-      referencedExpression.variable
+      referencedExpression.field
     );
     const reader = this.createReaderMethod(variableGetAccess);
     let writer;
@@ -58767,12 +58941,17 @@ var ReferenceExpressionLowering = class extends ExecutableCodeLowering {
       const variableSetAccess = FieldAccessExpression.set(
         receiverGetAccess,
         referencedExpression.isOptionalAccess,
-        referencedExpression.variable
+        referencedExpression.field
       );
       writer = this.createWriterMethod(variableSetAccess);
     }
     const reference = this.createReference(reader, writer, sourceLocation);
-    const commaExpression = new CommaExpression([receiverAssignment, reference], void 0);
+    const expressions = new Array();
+    if (receiverAssignment !== void 0) {
+      expressions.push(receiverAssignment);
+    }
+    expressions.push(reference);
+    const commaExpression = new CommaExpression(expressions, void 0);
     return { expression: commaExpression, tempVariables };
   }
   createReaderMethod(getExpression) {
@@ -58948,7 +59127,8 @@ var IsExpressionLowering = class extends ExecutableCodeLowering {
   lower(expression) {
     let type = expression.type;
     if (type.equals(this._ctx.ectx.standardTypes.integer)) {
-      const [expressionTemp, expressionTempAssignment, expressionTempAccess] = this.createInitializedTemporaryVariable(expression.expression);
+      const tempVariables = new Array();
+      const [, expressionTempAssignment, expressionTempAccess] = this.createCachingTemporaryVariable(expression.expression, tempVariables);
       const typeOfCheck = this.createTypeOfCheck(expressionTempAccess, "number", expression.sourceLocation);
       const numberIsIntegerCheck = this._ctx.helperFunctions.createNumberIsIntegerFunctionCall(expressionTempAccess);
       const combinedCheck = new BinaryExpression3(
@@ -58959,8 +59139,13 @@ var IsExpressionLowering = class extends ExecutableCodeLowering {
         void 0,
         void 0
       );
-      const commaExpression = new CommaExpression([expressionTempAssignment, combinedCheck], void 0);
-      return { expression: commaExpression, tempVariables: [expressionTemp] };
+      const expressions = new Array();
+      if (expressionTempAssignment !== void 0) {
+        expressions.push(expressionTempAssignment);
+      }
+      expressions.push(combinedCheck);
+      const commaExpression = new CommaExpression(expressions, void 0);
+      return { expression: commaExpression, tempVariables };
     }
     if (type.equals(this._ctx.ectx.standardTypes.number)) {
       return { expression: this.createTypeOfCheck(expression.expression, "number", expression.sourceLocation) };
@@ -59050,7 +59235,7 @@ var BaseAspectMemberAccessLowering = class extends ExecutableCodeLowering {
     return void 0;
   }
   tryLowerFieldAccessExpression(node) {
-    const entity = node.variable.entity;
+    const entity = node.field.entity;
     if (this.isReceiverBaseExpression(node.expression) && this.isSourceAspectType(entity.ifTypeMemberThenContainingType)) {
       Debug.assert(node.accessKind === 0 /* Get */);
       return replaceExpression(this.lowerBaseAspectFieldGetAccess(node));
@@ -59062,7 +59247,7 @@ var BaseAspectMemberAccessLowering = class extends ExecutableCodeLowering {
     if (left.kind !== 69 /* FieldAccessExpression */) {
       return void 0;
     }
-    const entity = left.variable.entity;
+    const entity = left.field.entity;
     if (this.isReceiverBaseExpression(left.expression) && this.isSourceAspectType(entity.ifTypeMemberThenContainingType)) {
       return replaceStatement(this.lowerBaseAspectFieldAssignment(node, left));
     }
@@ -59107,12 +59292,12 @@ var BaseAspectMemberAccessLowering = class extends ExecutableCodeLowering {
    *    JS: Object.getOwnPropertyDescriptor(Aspect.prototype, 'f1').get.call(this)
    */
   lowerBaseAspectFieldGetAccess(node) {
-    const containingType = node.variable.entity.ifTypeMemberThenContainingType;
+    const containingType = node.field.entity.ifTypeMemberThenContainingType;
     Debug.assertNotNull(containingType);
     const aspectPrototypeAccess = this._ctx.createPrototypeAccess(new TypeAccessExpression(containingType, void 0));
     const getOwnPropertyDescriptorCall = this._ctx.createGetOwnPropertyDescriptorCall(
       aspectPrototypeAccess,
-      new TextWithEntityName(node.variable.entity, void 0)
+      new TextWithEntityName(node.field.entity, void 0)
     );
     const descriptorGetAccess = new JsPropertyAccessExpression(
       getOwnPropertyDescriptorCall,
@@ -59126,19 +59311,19 @@ var BaseAspectMemberAccessLowering = class extends ExecutableCodeLowering {
       [new ThisExpression(this._ctx.ectx.type.ofExpression(node.expression), void 0)],
       false
     );
-    return new CallExpression5(callMethodAccess, false, callArguments, false, node.variable.type, node.sourceLocation);
+    return new CallExpression5(callMethodAccess, false, callArguments, false, node.field.type, node.sourceLocation);
   }
   /**
    * Artel: base.f1 = value
    *    JS: Object.getOwnPropertyDescriptor(Aspect.prototype, 'f1').set.call(this, value)
    */
   lowerBaseAspectFieldAssignment(node, left) {
-    const containingType = left.variable.entity.ifTypeMemberThenContainingType;
+    const containingType = left.field.entity.ifTypeMemberThenContainingType;
     Debug.assertNotNull(containingType);
     const aspectPrototypeAccess = this._ctx.createPrototypeAccess(new TypeAccessExpression(containingType, void 0));
     const getOwnPropertyDescriptorCall = this._ctx.createGetOwnPropertyDescriptorCall(
       aspectPrototypeAccess,
-      new TextWithEntityName(left.variable.entity, void 0)
+      new TextWithEntityName(left.field.entity, void 0)
     );
     const descriptorGetAccess = new JsPropertyAccessExpression(
       getOwnPropertyDescriptorCall,
@@ -59157,16 +59342,13 @@ var BaseAspectMemberAccessLowering = class extends ExecutableCodeLowering {
       false,
       callArguments,
       false,
-      left.variable.type,
+      left.field.type,
       node.sourceLocation
     );
     return new ExpressionStatement3(expression, node.sourceLocation);
   }
   isReceiverBaseExpression(node) {
-    if (node.kind === 0 /* AsExpression */) {
-      node = node.expression;
-    }
-    return node.kind === 89 /* BaseExpression */;
+    return this._ctx.isPossiblyCastedBaseExpression(node);
   }
   isSourceAspectType(entity) {
     return entity?.typeOrExtensionKind === 0 /* StructuredType */ && entity.details.structuredTypeKind === 2 /* Aspect */ && entity.containingPackage.details.isSource;
@@ -62117,7 +62299,7 @@ var _IrToJs = class _IrToJs {
       property = this.convertExpression(expression.ifComputedThenKey);
       computed = true;
     } else {
-      const name = this.getEntityName(expression.variable.entity);
+      const name = this.getEntityName(expression.field.entity);
       computed = !js.isValidIdentifier(name);
       property = computed ? js.stringLiteral(name) : js.identifier(name);
     }