Several tests for AnalysisDriver and an elements.dart tweak.

pkg/analyzer/lib/src/dart/element/element.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 15 matching lines @@
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/task/dart.dart';
 
 /**
+ * Assert that the given [object] is null, which in the places where this
+ * function is called means that the element is not resynthesized.
+ */
+void _assertNotResynthesized(Object object) {
+  // TODO(scheglov) I comment this check for now.
+  // When we make a decision about switch to the new analysis driver,
+  // we will need to rework the analysis code to don't call the setters
+  // or restore / inline it.
+//  assert(object == null);
+}
+
+/**
  * A concrete implementation of a [ClassElement].
  */
 abstract class AbstractClassElementImpl extends ElementImpl
     implements ClassElement {
   /**
    * A list containing all of the accessors (getters and setters) contained in
    * this class.
    */
   List<PropertyAccessorElement> _accessors;
 
@@ skipping 452 matching lines @@
    * Initialize using the given serialized information.
    */
   ClassElementImpl.forSerialized(
       this._unlinkedClass, CompilationUnitElementImpl enclosingUnit)
       : super.forSerialized(enclosingUnit);
 
   /**
    * Set whether this class is abstract.
    */
   void set abstract(bool isAbstract) {
-    assert(_unlinkedClass == null);
+    _assertNotResynthesized(_unlinkedClass);
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
 
   @override
   List<PropertyAccessorElement> get accessors {
     if (_unlinkedClass != null && _accessors == null) {
       _resynthesizeFieldsAndPropertyAccessors();
     }
     return _accessors ?? const <PropertyAccessorElement>[];
   }
 
   @override
   void set accessors(List<PropertyAccessorElement> accessors) {
-    assert(_unlinkedClass == null);
+    _assertNotResynthesized(_unlinkedClass);
     super.accessors = accessors;
   }
 
   @override
   List<InterfaceType> get allSupertypes {
     List<InterfaceType> list = new List<InterfaceType>();
     _collectAllSupertypes(list);
     return list;
   }
 
@@ skipping 34 matching lines @@
     assert(_constructors != null);
     return _constructors ?? const <ConstructorElement>[];
   }
 
   /**
    * Set the constructors contained in this class to the given [constructors].
    *
    * Should only be used for class elements that are not mixin applications.
    */
   void set constructors(List<ConstructorElement> constructors) {
-    assert(_unlinkedClass == null);
+    _assertNotResynthesized(_unlinkedClass);
     assert(!isMixinApplication);
     for (ConstructorElement constructor in constructors) {
       (constructor as ConstructorElementImpl).enclosingElement = this;
     }
     this._constructors = constructors;
   }
 
   @override
   String get documentationComment {
     if (_unlinkedClass != null) {
@@ skipping 52 matching lines @@
   @override
   List<FieldElement> get fields {
     if (_unlinkedClass != null && _fields == null) {
       _resynthesizeFieldsAndPropertyAccessors();
     }
     return _fields ?? const <FieldElement>[];
   }
 
   @override
   void set fields(List<FieldElement> fields) {
-    assert(_unlinkedClass == null);
+    _assertNotResynthesized(_unlinkedClass);
     super.fields = fields;
   }
 
   bool get hasBeenInferred {
     if (_unlinkedClass != null) {
       return context.analysisOptions.strongMode;
     }
     return _hasBeenInferred;
   }
 
   void set hasBeenInferred(bool hasBeenInferred) {
-    assert(_unlinkedClass == null);
+    _assertNotResynthesized(_unlinkedClass);
     _hasBeenInferred = hasBeenInferred;
   }
 
   @override
   bool get hasNonFinalField {
     List<ClassElement> classesToVisit = new List<ClassElement>();
     HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
     classesToVisit.add(this);
     while (!classesToVisit.isEmpty) {
       ClassElement currentElement = classesToVisit.removeAt(0);
@@ skipping 69 matching lines @@
       ResynthesizerContext context = enclosingUnit.resynthesizerContext;
       _interfaces = _unlinkedClass.interfaces
           .map((EntityRef t) => context.resolveTypeRef(t, this))
           .where((DartType type) => type is InterfaceType)
           .toList(growable: false);
     }
     return _interfaces ?? const <InterfaceType>[];
   }
 
   void set interfaces(List<InterfaceType> interfaces) {
-    assert(_unlinkedClass == null);
+    _assertNotResynthesized(_unlinkedClass);
     _interfaces = interfaces;
   }
 
   @override
   bool get isAbstract {
     if (_unlinkedClass != null) {
       return _unlinkedClass.isAbstract;
     }
     return hasModifier(Modifier.ABSTRACT);
   }
@@ skipping 58 matching lines @@
           .map((e) => new MethodElementImpl.forSerialized(e, this))
           .toList(growable: false);
     }
     return _methods ?? const <MethodElement>[];
   }
 
   /**
    * Set the methods contained in this class to the given [methods].
    */
   void set methods(List<MethodElement> methods) {
-    assert(_unlinkedClass == null);
+    _assertNotResynthesized(_unlinkedClass);
     for (MethodElement method in methods) {
       (method as MethodElementImpl).enclosingElement = this;
     }
     _methods = methods;
   }
 
   /**
    * Set whether this class is a mixin application.
    */
   void set mixinApplication(bool isMixinApplication) {
-    assert(_unlinkedClass == null);
+    _assertNotResynthesized(_unlinkedClass);
     setModifier(Modifier.MIXIN_APPLICATION, isMixinApplication);
   }
 
   @override
   List<InterfaceType> get mixins {
     if (_unlinkedClass != null && _mixins == null) {
       ResynthesizerContext context = enclosingUnit.resynthesizerContext;
       _mixins = _unlinkedClass.mixins
           .map((EntityRef t) => context.resolveTypeRef(t, this))
           .where((DartType type) => type is InterfaceType)
           .toList(growable: false);
     }
     return _mixins ?? const <InterfaceType>[];
   }
 
   void set mixins(List<InterfaceType> mixins) {
-    assert(_unlinkedClass == null);
+    _assertNotResynthesized(_unlinkedClass);
     _mixins = mixins;
   }
 
   @override
   String get name {
     if (_unlinkedClass != null) {
       return _unlinkedClass.name;
     }
     return super.name;
   }
@@ skipping 21 matching lines @@
       } else if (_unlinkedClass.hasNoSupertype) {
         return null;
       } else {
         _supertype = context.typeProvider.objectType;
       }
     }
     return _supertype;
   }
 
   void set supertype(InterfaceType supertype) {
-    assert(_unlinkedClass == null);
+    _assertNotResynthesized(_unlinkedClass);
     _supertype = supertype;
   }
 
   @override
   InterfaceType get type {
     if (_type == null) {
       InterfaceTypeImpl type = new InterfaceTypeImpl(this);
       type.typeArguments = typeParameterTypes;
       _type = type;
     }
     return _type;
   }
 
   @override
   TypeParameterizedElementMixin get typeParameterContext => this;
 
   @override
   List<TypeParameterElement> get typeParameters {
     if (_unlinkedClass != null) {
       return super.typeParameters;
     }
     return _typeParameters;
   }
 
   /**
    * Set the type parameters defined for this class to the given
    * [typeParameters].
    */
   void set typeParameters(List<TypeParameterElement> typeParameters) {
-    assert(_unlinkedClass == null);
+    _assertNotResynthesized(_unlinkedClass);
     for (TypeParameterElement typeParameter in typeParameters) {
       (typeParameter as TypeParameterElementImpl).enclosingElement = this;
     }
     this._typeParameters = typeParameters;
   }
 
   @override
   List<UnlinkedTypeParam> get unlinkedTypeParams =>
       _unlinkedClass.typeParameters;
 
@@ skipping 529 matching lines @@
           .map((e) => new EnumElementImpl.forSerialized(e, this))
           .toList(growable: false);
     }
     return _enums ?? const <ClassElement>[];
   }
 
   /**
    * Set the enums contained in this compilation unit to the given [enums].
    */
   void set enums(List<ClassElement> enums) {
-    assert(_unlinkedUnit == null);
+    _assertNotResynthesized(_unlinkedUnit);
     for (ClassElement enumDeclaration in enums) {
       (enumDeclaration as EnumElementImpl).enclosingElement = this;
     }
     this._enums = enums;
   }
 
   @override
   List<FunctionElement> get functions {
     if (_unlinkedUnit != null) {
       _functions ??= _unlinkedUnit.executables
@@ skipping 93 matching lines @@
       (field as TopLevelVariableElementImpl).enclosingElement = this;
     }
     this._variables = variables;
   }
 
   /**
    * Set the function type aliases contained in this compilation unit to the
    * given [typeAliases].
    */
   void set typeAliases(List<FunctionTypeAliasElement> typeAliases) {
-    assert(_unlinkedUnit == null);
+    _assertNotResynthesized(_unlinkedUnit);
     for (FunctionTypeAliasElement typeAlias in typeAliases) {
       (typeAlias as FunctionTypeAliasElementImpl).enclosingElement = this;
     }
     this._typeAliases = typeAliases;
   }
 
   @override
   TypeParameterizedElementMixin get typeParameterContext => null;
 
   @override
   List<ClassElement> get types {
     if (_unlinkedUnit != null) {
       _types ??= _unlinkedUnit.classes
           .map((c) => new ClassElementImpl.forSerialized(c, this))
           .toList(growable: false);
     }
     return _types ?? const <ClassElement>[];
   }
 
   /**
    * Set the types contained in this compilation unit to the given [types].
    */
   void set types(List<ClassElement> types) {
-    assert(_unlinkedUnit == null);
+    _assertNotResynthesized(_unlinkedUnit);
     for (ClassElement type in types) {
       // Another implementation of ClassElement is _DeferredClassElement,
       // which is used to resynthesize classes lazily. We cannot cast it
       // to ClassElementImpl, and it already can provide correct values of the
       // 'enclosingElement' property.
       if (type is ClassElementImpl) {
         type.enclosingElement = this;
       }
     }
     this._types = types;
@@ skipping 385 matching lines @@
    * Initialize using the given serialized information.
    */
   ConstructorElementImpl.forSerialized(
       UnlinkedExecutable serializedExecutable, ClassElementImpl enclosingClass)
       : super.forSerialized(serializedExecutable, enclosingClass);
 
   /**
    * Set whether this constructor represents a 'const' constructor.
    */
   void set const2(bool isConst) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.CONST, isConst);
   }
 
   List<ConstructorInitializer> get constantInitializers {
     if (serializedExecutable != null && _constantInitializers == null) {
       _constantInitializers ??= serializedExecutable.constantInitializers
           .map((i) => _buildConstructorInitializer(i))
           .toList(growable: false);
     }
     return _constantInitializers;
   }
 
   void set constantInitializers(
       List<ConstructorInitializer> constantInitializers) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     _constantInitializers = constantInitializers;
   }
 
   @override
   ClassElementImpl get enclosingElement =>
       super.enclosingElement as ClassElementImpl;
 
   @override
   TypeParameterizedElementMixin get enclosingTypeParameterContext =>
       super.enclosingElement as ClassElementImpl;
 
   /**
    * Set whether this constructor represents a factory method.
    */
   void set factory(bool isFactory) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.FACTORY, isFactory);
   }
 
   @override
   bool get isConst {
     if (serializedExecutable != null) {
       return serializedExecutable.isConst;
     }
     return hasModifier(Modifier.CONST);
   }
@@ skipping 50 matching lines @@
       if (serializedExecutable.name.isNotEmpty) {
         return serializedExecutable.nameEnd;
       } else {
         return serializedExecutable.nameOffset + enclosingElement.name.length;
       }
     }
     return _nameEnd;
   }
 
   void set nameEnd(int nameEnd) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     _nameEnd = nameEnd;
   }
 
   @override
   int get periodOffset {
     if (serializedExecutable != null) {
       if (serializedExecutable.name.isNotEmpty) {
         return serializedExecutable.periodOffset;
       }
     }
     return _periodOffset;
   }
 
   void set periodOffset(int periodOffset) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     _periodOffset = periodOffset;
   }
 
   @override
   ConstructorElement get redirectedConstructor {
     if (serializedExecutable != null && _redirectedConstructor == null) {
       if (serializedExecutable.isRedirectedConstructor) {
         if (serializedExecutable.isFactory) {
           _redirectedConstructor = enclosingUnit.resynthesizerContext
               .resolveConstructorRef(
                   enclosingElement, serializedExecutable.redirectedConstructor);
         } else {
           _redirectedConstructor = enclosingElement.getNamedConstructor(
               serializedExecutable.redirectedConstructorName);
         }
       } else {
         return null;
       }
     }
     return _redirectedConstructor;
   }
 
   void set redirectedConstructor(ConstructorElement redirectedConstructor) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     _redirectedConstructor = redirectedConstructor;
   }
 
   @override
   DartType get returnType => enclosingElement.type;
 
   void set returnType(DartType returnType) {
     assert(false);
   }
 
@@ skipping 151 matching lines @@
 
   Expression get constantInitializer {
     if (_constantInitializer == null && _unlinkedConst != null) {
       _constantInitializer = enclosingUnit.resynthesizerContext
           .buildExpression(this, _unlinkedConst);
     }
     return _constantInitializer;
   }
 
   void set constantInitializer(Expression constantInitializer) {
-    assert(_unlinkedConst == null);
+    _assertNotResynthesized(_unlinkedConst);
     _constantInitializer = constantInitializer;
   }
 
   EvaluationResultImpl get evaluationResult => _evaluationResult;
 
   void set evaluationResult(EvaluationResultImpl evaluationResult) {
     _evaluationResult = evaluationResult;
   }
 
   /**
@@ skipping 1002 matching lines @@
    * Initialize using the given serialized information.
    */
   EnumElementImpl.forSerialized(
       this._unlinkedEnum, CompilationUnitElementImpl enclosingUnit)
       : super.forSerialized(enclosingUnit);
 
   /**
    * Set whether this class is abstract.
    */
   void set abstract(bool isAbstract) {
-    assert(_unlinkedEnum == null);
+    _assertNotResynthesized(_unlinkedEnum);
   }
 
   @override
   List<PropertyAccessorElement> get accessors {
     if (_unlinkedEnum != null && _accessors == null) {
       _resynthesizeFieldsAndPropertyAccessors();
     }
     return _accessors ?? const <PropertyAccessorElement>[];
   }
 
   @override
   void set accessors(List<PropertyAccessorElement> accessors) {
-    assert(_unlinkedEnum == null);
+    _assertNotResynthesized(_unlinkedEnum);
     super.accessors = accessors;
   }
 
   @override
   List<InterfaceType> get allSupertypes => <InterfaceType>[supertype];
 
   @override
   int get codeLength {
     if (_unlinkedEnum != null) {
       return _unlinkedEnum.codeRange?.length;
@@ skipping 29 matching lines @@
   @override
   List<FieldElement> get fields {
     if (_unlinkedEnum != null && _fields == null) {
       _resynthesizeFieldsAndPropertyAccessors();
     }
     return _fields ?? const <FieldElement>[];
   }
 
   @override
   void set fields(List<FieldElement> fields) {
-    assert(_unlinkedEnum == null);
+    _assertNotResynthesized(_unlinkedEnum);
     super.fields = fields;
   }
 
   @override
   bool get hasNonFinalField => false;
 
   @override
   bool get hasReferenceToSuper => false;
 
   @override
@@ skipping 187 matching lines @@
    * Initialize using the given serialized information.
    */
   ExecutableElementImpl.forSerialized(
       this.serializedExecutable, ElementImpl enclosingElement)
       : super.forSerialized(enclosingElement);
 
   /**
    * Set whether this executable element's body is asynchronous.
    */
   void set asynchronous(bool isAsynchronous) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.ASYNCHRONOUS, isAsynchronous);
   }
 
   @override
   int get codeLength {
     if (serializedExecutable != null) {
       return serializedExecutable.codeRange?.length;
     }
     return super.codeLength;
   }
@@ skipping 19 matching lines @@
     if (serializedExecutable != null) {
       return serializedExecutable?.documentationComment?.text;
     }
     return super.documentationComment;
   }
 
   /**
    * Set whether this executable element is external.
    */
   void set external(bool isExternal) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.EXTERNAL, isExternal);
   }
 
   @override
   List<FunctionElement> get functions {
     if (serializedExecutable != null) {
       _functions ??= FunctionElementImpl.resynthesizeList(
           this, serializedExecutable.localFunctions);
     }
     return _functions ?? const <FunctionElement>[];
   }
 
   /**
    * Set the functions defined within this executable element to the given
    * [functions].
    */
   void set functions(List<FunctionElement> functions) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     for (FunctionElement function in functions) {
       (function as FunctionElementImpl).enclosingElement = this;
     }
     this._functions = functions;
   }
 
   /**
    * Set whether this method's body is a generator.
    */
   void set generator(bool isGenerator) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.GENERATOR, isGenerator);
   }
 
   @override
   bool get hasImplicitReturnType {
     if (serializedExecutable != null) {
       return serializedExecutable.returnType == null &&
           serializedExecutable.kind != UnlinkedExecutableKind.constructor;
     }
     return hasModifier(Modifier.IMPLICIT_TYPE);
   }
 
   /**
    * Set whether this executable element has an implicit return type.
    */
   void set hasImplicitReturnType(bool hasImplicitReturnType) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.IMPLICIT_TYPE, hasImplicitReturnType);
   }
 
   @override
   bool get isAbstract {
     if (serializedExecutable != null) {
       return serializedExecutable.isAbstract;
     }
     return hasModifier(Modifier.ABSTRACT);
   }
@@ skipping 35 matching lines @@
           this, serializedExecutable.localLabels);
     }
     return _labels ?? const <LabelElement>[];
   }
 
   /**
    * Set the labels defined within this executable element to the given
    * [labels].
    */
   void set labels(List<LabelElement> labels) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     for (LabelElement label in labels) {
       (label as LabelElementImpl).enclosingElement = this;
     }
     this._labels = labels;
   }
 
   @override
   List<LocalVariableElement> get localVariables {
     if (serializedExecutable != null && _localVariables == null) {
       List<UnlinkedVariable> unlinkedVariables =
@@ skipping 12 matching lines @@
       }
     }
     return _localVariables ?? const <LocalVariableElement>[];
   }
 
   /**
    * Set the local variables defined within this executable element to the given
    * [variables].
    */
   void set localVariables(List<LocalVariableElement> variables) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     for (LocalVariableElement variable in variables) {
       (variable as LocalVariableElementImpl).enclosingElement = this;
     }
     this._localVariables = variables;
   }
 
   @override
   List<ElementAnnotation> get metadata {
     if (serializedExecutable != null) {
       return _metadata ??=
@@ skipping 26 matching lines @@
           serializedExecutable.parameters, this);
     }
     return _parameters ?? const <ParameterElement>[];
   }
 
   /**
    * Set the parameters defined by this executable element to the given
    * [parameters].
    */
   void set parameters(List<ParameterElement> parameters) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
     this._parameters = parameters;
   }
 
   @override
   DartType get returnType {
     if (serializedExecutable != null && _returnType == null) {
       bool isSetter =
           serializedExecutable.kind == UnlinkedExecutableKind.setter;
       _returnType = enclosingUnit.resynthesizerContext.resolveLinkedType(
               serializedExecutable.inferredReturnTypeSlot,
               typeParameterContext) ??
           enclosingUnit.resynthesizerContext.resolveTypeRef(
               serializedExecutable.returnType, typeParameterContext,
               defaultVoid: isSetter && context.analysisOptions.strongMode);
     }
     return _returnType;
   }
 
   void set returnType(DartType returnType) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     _returnType = returnType;
   }
 
   @override
   FunctionType get type {
     if (serializedExecutable != null) {
       _type ??= new FunctionTypeImpl.elementWithNameAndArgs(
           this, null, allEnclosingTypeParameterTypes, false);
     }
     return _type;
   }
 
   void set type(FunctionType type) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     _type = type;
   }
 
   @override
   TypeParameterizedElementMixin get typeParameterContext => this;
 
   @override
   List<TypeParameterElement> get typeParameters {
     if (serializedExecutable != null) {
       return super.typeParameters;
     }
     return _typeParameters ?? const <TypeParameterElement>[];
   }
 
   /**
    * Set the type parameters defined by this executable element to the given
    * [typeParameters].
    */
   void set typeParameters(List<TypeParameterElement> typeParameters) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     for (TypeParameterElement parameter in typeParameters) {
       (parameter as TypeParameterElementImpl).enclosingElement = this;
     }
     this._typeParameters = typeParameters;
   }
 
   @override
   List<UnlinkedTypeParam> get unlinkedTypeParams =>
       serializedExecutable.typeParameters;
 
@@ skipping 138 matching lines @@
   @override
   List<NamespaceCombinator> get combinators {
     if (_unlinkedExportPublic != null && _combinators == null) {
       _combinators = ImportElementImpl
           ._buildCombinators(_unlinkedExportPublic.combinators);
     }
     return _combinators ?? const <NamespaceCombinator>[];
   }
 
   void set combinators(List<NamespaceCombinator> combinators) {
-    assert(_unlinkedExportPublic == null);
+    _assertNotResynthesized(_unlinkedExportPublic);
     _combinators = combinators;
   }
 
   @override
   LibraryElement get exportedLibrary {
     if (_unlinkedExportNonPublic != null && _exportedLibrary == null) {
       LibraryElementImpl library = enclosingElement as LibraryElementImpl;
       _exportedLibrary = library.resynthesizerContext.buildExportedLibrary(uri);
     }
     return _exportedLibrary;
   }
 
   void set exportedLibrary(LibraryElement exportedLibrary) {
-    assert(_unlinkedExportNonPublic == null);
+    _assertNotResynthesized(_unlinkedExportNonPublic);
     _exportedLibrary = exportedLibrary;
   }
 
   @override
   String get identifier => exportedLibrary.name;
 
   @override
   ElementKind get kind => ElementKind.EXPORT;
 
   @override
   List<ElementAnnotation> get metadata {
     if (_unlinkedExportNonPublic != null) {
       return _metadata ??= _buildAnnotations(
           library.definingCompilationUnit as CompilationUnitElementImpl,
           _unlinkedExportNonPublic.annotations);
     }
     return super.metadata;
   }
 
   void set metadata(List<ElementAnnotation> metadata) {
-    assert(_unlinkedExportNonPublic == null);
+    _assertNotResynthesized(_unlinkedExportNonPublic);
     super.metadata = metadata;
   }
 
   @override
   int get nameOffset {
     int offset = super.nameOffset;
     if (offset == 0 && _unlinkedExportNonPublic != null) {
       return _unlinkedExportNonPublic.offset;
     }
     return offset;
   }
 
   @override
   String get uri {
     if (_unlinkedExportPublic != null) {
       return _selectedUri ??= _selectUri(
           _unlinkedExportPublic.uri, _unlinkedExportPublic.configurations);
     }
     return super.uri;
   }
 
   @override
   void set uri(String uri) {
-    assert(_unlinkedExportPublic == null);
+    _assertNotResynthesized(_unlinkedExportPublic);
     super.uri = uri;
   }
 
   @override
   int get uriEnd {
     if (_unlinkedExportNonPublic != null) {
       return _unlinkedExportNonPublic.uriEnd;
     }
     return super.uriEnd;
   }
 
   @override
   void set uriEnd(int uriEnd) {
-    assert(_unlinkedExportNonPublic == null);
+    _assertNotResynthesized(_unlinkedExportNonPublic);
     super.uriEnd = uriEnd;
   }
 
   @override
   int get uriOffset {
     if (_unlinkedExportNonPublic != null) {
       return _unlinkedExportNonPublic.uriOffset;
     }
     return super.uriOffset;
   }
 
   @override
   void set uriOffset(int uriOffset) {
-    assert(_unlinkedExportNonPublic == null);
+    _assertNotResynthesized(_unlinkedExportNonPublic);
     super.uriOffset = uriOffset;
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitExportElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write("export ");
     (exportedLibrary as LibraryElementImpl).appendTo(buffer);
@@ skipping 64 matching lines @@
     return false;
   }
 
   @override
   ElementKind get kind => ElementKind.FIELD;
 
   /**
    * Set whether this field is static.
    */
   void set static(bool isStatic) {
-    assert(_unlinkedVariable == null);
+    _assertNotResynthesized(_unlinkedVariable);
     setModifier(Modifier.STATIC, isStatic);
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
 
   @override
   AstNode computeNode() {
     if (isEnumConstant) {
       return getNodeMatching((node) => node is EnumConstantDeclaration);
@@ skipping 39 matching lines @@
     if (_unlinkedParam != null && _field == null) {
       Element enclosingClass = enclosingElement?.enclosingElement;
       if (enclosingClass is ClassElement) {
         _field = enclosingClass.getField(_unlinkedParam.name);
       }
     }
     return _field;
   }
 
   void set field(FieldElement field) {
-    assert(_unlinkedParam == null);
+    _assertNotResynthesized(_unlinkedParam);
     _field = field;
   }
 
   @override
   bool get isInitializingFormal => true;
 
   @override
   DartType get type {
     if (_unlinkedParam != null && _unlinkedParam.type == null) {
       _type ??= field?.type ?? DynamicTypeImpl.instance;
     }
     return super.type;
   }
 
   @override
   void set type(DartType type) {
-    assert(_unlinkedParam == null);
+    _assertNotResynthesized(_unlinkedParam);
     _type = type;
   }
 
   @override
   accept(ElementVisitor visitor) =>
       visitor.visitFieldFormalParameterElement(this);
 }
 
 /**
  * A concrete implementation of a [FunctionElement].
@@ skipping 106 matching lines @@
 
   @override
   FunctionDeclaration computeNode() =>
       getNodeMatching((node) => node is FunctionDeclaration);
 
   /**
    * Set the visible range for this element to the range starting at the given
    * [offset] with the given [length].
    */
   void setVisibleRange(int offset, int length) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
 
   /**
    * Set the parameters defined by this type alias to the given [parameters]
    * without becoming the parent of the parameters. This should only be used by
    * the [TypeResolverVisitor] when creating a synthetic type alias.
    */
   void shareParameters(List<ParameterElement> parameters) {
@@ skipping 238 matching lines @@
       _parameters ??= ParameterElementImpl.resynthesizeList(
           _unlinkedTypedef.parameters, this);
     }
     return _parameters ?? const <ParameterElement>[];
   }
 
   /**
    * Set the parameters defined by this type alias to the given [parameters].
    */
   void set parameters(List<ParameterElement> parameters) {
-    assert(_unlinkedTypedef == null);
+    _assertNotResynthesized(_unlinkedTypedef);
     if (parameters != null) {
       for (ParameterElement parameter in parameters) {
         (parameter as ParameterElementImpl).enclosingElement = this;
       }
     }
     this._parameters = parameters;
   }
 
   @override
   DartType get returnType {
     if (_unlinkedTypedef != null && _returnType == null) {
       _returnType = enclosingUnit.resynthesizerContext
           .resolveTypeRef(_unlinkedTypedef.returnType, this);
     }
     return _returnType;
   }
 
   void set returnType(DartType returnType) {
-    assert(_unlinkedTypedef == null);
+    _assertNotResynthesized(_unlinkedTypedef);
     _returnType = returnType;
   }
 
   @override
   FunctionType get type {
     if (_unlinkedTypedef != null && _type == null) {
       _type = new FunctionTypeImpl.forTypedef(this);
     }
     return _type;
   }
 
   void set type(FunctionType type) {
-    assert(_unlinkedTypedef == null);
+    _assertNotResynthesized(_unlinkedTypedef);
     _type = type;
   }
 
   @override
   TypeParameterizedElementMixin get typeParameterContext => this;
 
   @override
   List<TypeParameterElement> get typeParameters {
     if (_unlinkedTypedef != null) {
       return super.typeParameters;
     }
     return _typeParameters;
   }
 
   /**
    * Set the type parameters defined for this type to the given
    * [typeParameters].
    */
   void set typeParameters(List<TypeParameterElement> typeParameters) {
-    assert(_unlinkedTypedef == null);
+    _assertNotResynthesized(_unlinkedTypedef);
     for (TypeParameterElement typeParameter in typeParameters) {
       (typeParameter as TypeParameterElementImpl).enclosingElement = this;
     }
     this._typeParameters = typeParameters;
   }
 
   @override
   List<UnlinkedTypeParam> get unlinkedTypeParams =>
       _unlinkedTypedef.typeParameters;
 
@@ skipping 86 matching lines @@
 
   @override
   List<String> get hiddenNames {
     if (_unlinkedCombinator != null) {
       _hiddenNames ??= _unlinkedCombinator.hides.toList(growable: false);
     }
     return _hiddenNames ?? const <String>[];
   }
 
   void set hiddenNames(List<String> hiddenNames) {
-    assert(_unlinkedCombinator == null);
+    _assertNotResynthesized(_unlinkedCombinator);
     _hiddenNames = hiddenNames;
   }
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     buffer.write("show ");
     int count = hiddenNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
@@ skipping 66 matching lines @@
 
   @override
   List<NamespaceCombinator> get combinators {
     if (_unlinkedImport != null && _combinators == null) {
       _combinators = _buildCombinators(_unlinkedImport.combinators);
     }
     return _combinators ?? const <NamespaceCombinator>[];
   }
 
   void set combinators(List<NamespaceCombinator> combinators) {
-    assert(_unlinkedImport == null);
+    _assertNotResynthesized(_unlinkedImport);
     _combinators = combinators;
   }
 
   /**
    * Set whether this import is for a deferred library.
    */
   void set deferred(bool isDeferred) {
-    assert(_unlinkedImport == null);
+    _assertNotResynthesized(_unlinkedImport);
     setModifier(Modifier.DEFERRED, isDeferred);
   }
 
   @override
   String get identifier => "${importedLibrary.identifier}@$nameOffset";
 
   @override
   LibraryElement get importedLibrary {
     if (_linkedDependency != null) {
       if (_importedLibrary == null) {
         LibraryElementImpl library = enclosingElement as LibraryElementImpl;
         if (_linkedDependency == 0) {
           _importedLibrary = library;
         } else {
           _importedLibrary = library.resynthesizerContext
               .buildImportedLibrary(_linkedDependency);
         }
       }
     }
     return _importedLibrary;
   }
 
   void set importedLibrary(LibraryElement importedLibrary) {
-    assert(_unlinkedImport == null);
+    _assertNotResynthesized(_unlinkedImport);
     _importedLibrary = importedLibrary;
   }
 
   @override
   bool get isDeferred {
     if (_unlinkedImport != null) {
       return _unlinkedImport.isDeferred;
     }
     return hasModifier(Modifier.DEFERRED);
   }
@@ skipping 13 matching lines @@
   List<ElementAnnotation> get metadata {
     if (_unlinkedImport != null) {
       return _metadata ??= _buildAnnotations(
           library.definingCompilationUnit as CompilationUnitElementImpl,
           _unlinkedImport.annotations);
     }
     return super.metadata;
   }
 
   void set metadata(List<ElementAnnotation> metadata) {
-    assert(_unlinkedImport == null);
+    _assertNotResynthesized(_unlinkedImport);
     super.metadata = metadata;
   }
 
   @override
   int get nameOffset {
     int offset = super.nameOffset;
     if (offset == 0 && _unlinkedImport != null) {
       if (_unlinkedImport.isImplicit) {
         return -1;
       }
       return _unlinkedImport.offset;
     }
     return offset;
   }
 
   PrefixElement get prefix {
     if (_unlinkedImport != null) {
       if (_unlinkedImport.prefixReference != 0 && _prefix == null) {
         LibraryElementImpl library = enclosingElement as LibraryElementImpl;
         _prefix = new PrefixElementImpl.forSerialized(_unlinkedImport, library);
       }
     }
     return _prefix;
   }
 
   void set prefix(PrefixElement prefix) {
-    assert(_unlinkedImport == null);
+    _assertNotResynthesized(_unlinkedImport);
     _prefix = prefix;
   }
 
   @override
   int get prefixOffset {
     if (_unlinkedImport != null) {
       return _unlinkedImport.prefixOffset;
     }
     return _prefixOffset;
   }
 
   void set prefixOffset(int prefixOffset) {
-    assert(_unlinkedImport == null);
+    _assertNotResynthesized(_unlinkedImport);
     _prefixOffset = prefixOffset;
   }
 
   @override
   String get uri {
     if (_unlinkedImport != null) {
       if (_unlinkedImport.isImplicit) {
         return null;
       }
       return _selectedUri ??=
           _selectUri(_unlinkedImport.uri, _unlinkedImport.configurations);
     }
     return super.uri;
   }
 
   @override
   void set uri(String uri) {
-    assert(_unlinkedImport == null);
+    _assertNotResynthesized(_unlinkedImport);
     super.uri = uri;
   }
 
   @override
   int get uriEnd {
     if (_unlinkedImport != null) {
       if (_unlinkedImport.isImplicit) {
         return -1;
       }
       return _unlinkedImport.uriEnd;
     }
     return super.uriEnd;
   }
 
   @override
   void set uriEnd(int uriEnd) {
-    assert(_unlinkedImport == null);
+    _assertNotResynthesized(_unlinkedImport);
     super.uriEnd = uriEnd;
   }
 
   @override
   int get uriOffset {
     if (_unlinkedImport != null) {
       if (_unlinkedImport.isImplicit) {
         return -1;
       }
       return _unlinkedImport.uriOffset;
     }
     return super.uriOffset;
   }
 
   @override
   void set uriOffset(int uriOffset) {
-    assert(_unlinkedImport == null);
+    _assertNotResynthesized(_unlinkedImport);
     super.uriOffset = uriOffset;
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitImportElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write("import ");
     (importedLibrary as LibraryElementImpl).appendTo(buffer);
@@ skipping 358 matching lines @@
       }
     }
     return _exports ?? const <ExportElement>[];
   }
 
   /**
    * Set the specifications of all of the exports defined in this library to the
    * given list of [exports].
    */
   void set exports(List<ExportElement> exports) {
-    assert(_unlinkedDefiningUnit == null);
+    _assertNotResynthesized(_unlinkedDefiningUnit);
     for (ExportElement exportElement in exports) {
       (exportElement as ExportElementImpl).enclosingElement = this;
     }
     this._exports = exports;
   }
 
   @override
   bool get hasExtUri => hasModifier(Modifier.HAS_EXT_URI);
 
   /**
@@ skipping 49 matching lines @@
       }
     }
     return _imports ?? ImportElement.EMPTY_LIST;
   }
 
   /**
    * Set the specifications of all of the imports defined in this library to the
    * given list of [imports].
    */
   void set imports(List<ImportElement> imports) {
-    assert(_unlinkedDefiningUnit == null);
+    _assertNotResynthesized(_unlinkedDefiningUnit);
     for (ImportElement importElement in imports) {
       (importElement as ImportElementImpl).enclosingElement = this;
       PrefixElementImpl prefix = importElement.prefix as PrefixElementImpl;
       if (prefix != null) {
         prefix.enclosingElement = this;
       }
     }
     this._imports = imports;
     this._prefixes = null;
   }
@@ skipping 509 matching lines @@
 
   @override
   Declaration computeNode() => getNodeMatching(
       (node) => node is DeclaredIdentifier || node is VariableDeclaration);
 
   /**
    * Set the visible range for this element to the range starting at the given
    * [offset] with the given [length].
    */
   void setVisibleRange(int offset, int length) {
-    assert(_unlinkedVariable == null);
+    _assertNotResynthesized(_unlinkedVariable);
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
 }
 
 /**
  * A concrete implementation of a [MethodElement].
  */
 class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
   /**
@@ skipping 11 matching lines @@
    * Initialize using the given serialized information.
    */
   MethodElementImpl.forSerialized(
       UnlinkedExecutable serializedExecutable, ClassElementImpl enclosingClass)
       : super.forSerialized(serializedExecutable, enclosingClass);
 
   /**
    * Set whether this method is abstract.
    */
   void set abstract(bool isAbstract) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
 
   @override
   List<TypeParameterType> get allEnclosingTypeParameterTypes {
     if (isStatic) {
       return const <TypeParameterType>[];
     }
     return super.allEnclosingTypeParameterTypes;
   }
@@ skipping 44 matching lines @@
     if (name == '-' && parameters.isEmpty) {
       return 'unary-';
     }
     return super.name;
   }
 
   /**
    * Set whether this method is static.
    */
   void set static(bool isStatic) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.STATIC, isStatic);
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(displayName);
     super.appendTo(buffer);
@@ skipping 481 matching lines @@
   @override
   int get codeOffset {
     if (_unlinkedVariable != null) {
       return _unlinkedVariable.codeRange?.offset;
     }
     return super.codeOffset;
   }
 
   @override
   void set const3(bool isConst) {
-    assert(_unlinkedVariable == null);
+    _assertNotResynthesized(_unlinkedVariable);
     super.const3 = isConst;
   }
 
   @override
   String get documentationComment {
     if (_unlinkedVariable != null) {
       return _unlinkedVariable?.documentationComment?.text;
     }
     return super.documentationComment;
   }
 
   @override
   void set final2(bool isFinal) {
-    assert(_unlinkedVariable == null);
+    _assertNotResynthesized(_unlinkedVariable);
     super.final2 = isFinal;
   }
 
   @override
   bool get hasImplicitType {
     if (_unlinkedVariable != null) {
       return _unlinkedVariable.type == null;
     }
     return super.hasImplicitType;
   }
 
   @override
   void set hasImplicitType(bool hasImplicitType) {
-    assert(_unlinkedVariable == null);
+    _assertNotResynthesized(_unlinkedVariable);
     super.hasImplicitType = hasImplicitType;
   }
 
   @override
   FunctionElement get initializer {
     if (_unlinkedVariable != null && _initializer == null) {
       UnlinkedExecutable unlinkedInitializer = _unlinkedVariable.initializer;
       if (unlinkedInitializer != null) {
         _initializer = new FunctionElementImpl.forSerialized(
             unlinkedInitializer, this)..synthetic = true;
       } else {
         return null;
       }
     }
     return super.initializer;
   }
 
   /**
    * Set the function representing this variable's initializer to the given
    * [function].
    */
   void set initializer(FunctionElement function) {
-    assert(_unlinkedVariable == null);
+    _assertNotResynthesized(_unlinkedVariable);
     super.initializer = function;
   }
 
   @override
   bool get isConst {
     if (_unlinkedVariable != null) {
       return _unlinkedVariable.isConst;
     }
     return super.isConst;
   }
@@ skipping 37 matching lines @@
     if (_unlinkedVariable != null && _type == null) {
       _type = enclosingUnit.resynthesizerContext.resolveLinkedType(
               _unlinkedVariable.inferredTypeSlot, typeParameterContext) ??
           enclosingUnit.resynthesizerContext
               .resolveTypeRef(_unlinkedVariable.type, typeParameterContext);
     }
     return super.type;
   }
 
   void set type(DartType type) {
-    assert(_unlinkedVariable == null);
+    _assertNotResynthesized(_unlinkedVariable);
     _type = type;
   }
 
   /**
    * Subclasses need this getter, see [ConstVariableElement._unlinkedConst].
    */
   UnlinkedConst get _unlinkedConst => _unlinkedVariable?.initializer?.bodyExpr;
 }
 
 /**
@@ skipping 117 matching lines @@
   @override
   int get codeOffset {
     if (_unlinkedParam != null) {
       return _unlinkedParam.codeRange?.offset;
     }
     return super.codeOffset;
   }
 
   @override
   void set const3(bool isConst) {
-    assert(_unlinkedParam == null);
+    _assertNotResynthesized(_unlinkedParam);
     super.const3 = isConst;
   }
 
   @override
   String get defaultValueCode {
     if (_unlinkedParam != null) {
       if (_unlinkedParam.initializer?.bodyExpr == null) {
         return null;
       }
       return _unlinkedParam.defaultValueCode;
     }
     return _defaultValueCode;
   }
 
   /**
    * Set Dart code of the default value.
    */
   void set defaultValueCode(String defaultValueCode) {
-    assert(_unlinkedParam == null);
+    _assertNotResynthesized(_unlinkedParam);
     this._defaultValueCode = StringUtilities.intern(defaultValueCode);
   }
 
   @override
   void set final2(bool isFinal) {
-    assert(_unlinkedParam == null);
+    _assertNotResynthesized(_unlinkedParam);
     super.final2 = isFinal;
   }
 
   @override
   bool get hasImplicitType {
     if (_unlinkedParam != null) {
       return _unlinkedParam.type == null;
     }
     return super.hasImplicitType;
   }
 
   @override
   void set hasImplicitType(bool hasImplicitType) {
-    assert(_unlinkedParam == null);
+    _assertNotResynthesized(_unlinkedParam);
     super.hasImplicitType = hasImplicitType;
   }
 
   /**
    * True if this parameter inherits from a covariant parameter. This happens
    * when it overrides a method in a supertype that has a corresponding
    * covariant parameter.
    */
   bool get inheritsCovariant {
     if (_unlinkedParam != null) {
       return enclosingUnit.resynthesizerContext
           .inheritsCovariant(_unlinkedParam.inheritsCovariantSlot);
     } else {
       return _inheritsCovariant;
     }
   }
 
   /**
    * Record whether or not this parameter inherits from a covariant parameter.
    */
   void set inheritsCovariant(bool value) {
-    assert(_unlinkedParam == null);
+    _assertNotResynthesized(_unlinkedParam);
     _inheritsCovariant = value;
   }
 
   @override
   FunctionElement get initializer {
     if (_unlinkedParam != null && _initializer == null) {
       UnlinkedExecutable unlinkedInitializer = _unlinkedParam.initializer;
       if (unlinkedInitializer != null) {
         _initializer = new FunctionElementImpl.forSerialized(
             unlinkedInitializer, this)..synthetic = true;
       } else {
         return null;
       }
     }
     return super.initializer;
   }
 
   /**
    * Set the function representing this variable's initializer to the given
    * [function].
    */
   void set initializer(FunctionElement function) {
-    assert(_unlinkedParam == null);
+    _assertNotResynthesized(_unlinkedParam);
     super.initializer = function;
   }
 
   @override
   bool get isConst {
     if (_unlinkedParam != null) {
       return false;
     }
     return super.isConst;
   }
@@ skipping 72 matching lines @@
           break;
         case UnlinkedParamKind.required:
           _parameterKind = ParameterKind.REQUIRED;
           break;
       }
     }
     return _parameterKind;
   }
 
   void set parameterKind(ParameterKind parameterKind) {
-    assert(_unlinkedParam == null);
+    _assertNotResynthesized(_unlinkedParam);
     _parameterKind = parameterKind;
   }
 
   @override
   List<ParameterElement> get parameters {
     _resynthesizeTypeAndParameters();
     return _parameters;
   }
 
   /**
@@ skipping 82 matching lines @@
       }
     }
     return null;
   }
 
   /**
    * Set the visible range for this element to the range starting at the given
    * [offset] with the given [length].
    */
   void setVisibleRange(int offset, int length) {
-    assert(_unlinkedParam == null);
+    _assertNotResynthesized(_unlinkedParam);
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(parameters, visitor);
   }
 
@@ skipping 231 matching lines @@
       : super(variable.name, variable.nameOffset) {
     this.variable = variable;
     static = variable.isStatic;
     synthetic = true;
   }
 
   /**
    * Set whether this accessor is abstract.
    */
   void set abstract(bool isAbstract) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
 
   @override
   List<TypeParameterType> get allEnclosingTypeParameterTypes {
     if (isStatic) {
       return const <TypeParameterType>[];
     }
     return super.allEnclosingTypeParameterTypes;
   }
@@ skipping 26 matching lines @@
 
   @override
   TypeParameterizedElementMixin get enclosingTypeParameterContext {
     return (enclosingElement as ElementImpl).typeParameterContext;
   }
 
   /**
    * Set whether this accessor is a getter.
    */
   void set getter(bool isGetter) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.GETTER, isGetter);
   }
 
   @override
   String get identifier {
     String name = displayName;
     String suffix = isGetter ? "?" : "=";
     return "$name$suffix";
   }
 
@@ skipping 38 matching lines @@
     if (isSetter) {
       return "${super.name}=";
     }
     return super.name;
   }
 
   /**
    * Set whether this accessor is a setter.
    */
   void set setter(bool isSetter) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.SETTER, isSetter);
   }
 
   /**
    * Set whether this accessor is static.
    */
   void set static(bool isStatic) {
-    assert(serializedExecutable == null);
+    _assertNotResynthesized(serializedExecutable);
     setModifier(Modifier.STATIC, isStatic);
   }
 
   @override
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(isGetter ? "get " : "set ");
     buffer.write(variable.displayName);
@@ skipping 141 matching lines @@
   @override
   DartType get propagatedType {
     if (_unlinkedVariable != null && _propagatedType == null) {
       _propagatedType = enclosingUnit.resynthesizerContext.resolveLinkedType(
           _unlinkedVariable.propagatedTypeSlot, typeParameterContext);
     }
     return _propagatedType;
   }
 
   void set propagatedType(DartType propagatedType) {
-    assert(_unlinkedVariable == null);
+    _assertNotResynthesized(_unlinkedVariable);
     _propagatedType = propagatedType;
   }
 }
 
 /**
  * The context in which elements are resynthesized.
  */
 abstract class ResynthesizerContext {
   /**
    * Build [ElementAnnotationImpl] for the given [UnlinkedConst].
@@ skipping 86 matching lines @@
 
   @override
   int get end {
     if (_unlinkedCombinator != null) {
       return _unlinkedCombinator.end;
     }
     return _end;
   }
 
   void set end(int end) {
-    assert(_unlinkedCombinator == null);
+    _assertNotResynthesized(_unlinkedCombinator);
     _end = end;
   }
 
   @override
   int get offset {
     if (_unlinkedCombinator != null) {
       return _unlinkedCombinator.offset;
     }
     return _offset;
   }
 
   void set offset(int offset) {
-    assert(_unlinkedCombinator == null);
+    _assertNotResynthesized(_unlinkedCombinator);
     _offset = offset;
   }
 
   @override
   List<String> get shownNames {
     if (_unlinkedCombinator != null) {
       _shownNames ??= _unlinkedCombinator.shows.toList(growable: false);
     }
     return _shownNames ?? const <String>[];
   }
 
   void set shownNames(List<String> shownNames) {
-    assert(_unlinkedCombinator == null);
+    _assertNotResynthesized(_unlinkedCombinator);
     _shownNames = shownNames;
   }
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     buffer.write("show ");
     int count = shownNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
@@ skipping 113 matching lines @@
         return null;
       }
       return _bound ??= enclosingUnit.resynthesizerContext.resolveTypeRef(
           _unlinkedTypeParam.bound, enclosingElement,
           instantiateToBoundsAllowed: false);
     }
     return _bound;
   }
 
   void set bound(DartType bound) {
-    assert(_unlinkedTypeParam == null);
+    _assertNotResynthesized(_unlinkedTypeParam);
     _bound = bound;
   }
 
   @override
   int get codeLength {
     if (_unlinkedTypeParam != null) {
       return _unlinkedTypeParam.codeRange?.length;
     }
     return super.codeLength;
   }
@@ skipping 447 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }