Replace uses of setModifier with ElementImpl setters.

pkg/analyzer/lib/src/summary/resynthesize.dart

 // Copyright (c) 2015, 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 summary_resynthesizer;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/element_handle.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 228 matching lines @@
   void buildClass(UnlinkedClass serializedClass) {
     try {
       currentTypeParameters =
           serializedClass.typeParameters.map(buildTypeParameter).toList();
       for (int i = 0; i < serializedClass.typeParameters.length; i++) {
         finishTypeParameter(
             serializedClass.typeParameters[i], currentTypeParameters[i]);
       }
       ClassElementImpl classElement =
           new ClassElementImpl(serializedClass.name, -1);
-      if (serializedClass.isMixinApplication) {
-        classElement.setModifier(Modifier.MIXIN_APPLICATION, true);
-      }
+      classElement.mixinApplication = serializedClass.isMixinApplication;
       InterfaceTypeImpl correspondingType = new InterfaceTypeImpl(classElement);
       if (serializedClass.supertype != null) {
         classElement.supertype = buildType(serializedClass.supertype);
       } else {
         // TODO(paulberry): don't make Object point to itself.
         classElement.supertype = summaryResynthesizer.typeProvider.objectType;
       }
       classElement.interfaces =
           serializedClass.interfaces.map(buildType).toList();
       classElement.mixins = serializedClass.mixins.map(buildType).toList();
@@ skipping 15 matching lines @@
         }
       }
       for (UnlinkedVariable serializedVariable in serializedClass.fields) {
         buildVariable(serializedVariable, memberHolder);
       }
       if (!serializedClass.isMixinApplication) {
         if (!constructorFound) {
           // Synthesize implicit constructors.
           ConstructorElementImpl constructor =
               new ConstructorElementImpl('', -1);
-          constructor.setModifier(Modifier.SYNTHETIC, true);
+          constructor.synthetic = true;
           constructor.returnType = correspondingType;
           constructor.type = new FunctionTypeImpl(constructor);
           memberHolder.addConstructor(constructor);
         }
         classElement.constructors = memberHolder.constructors;
       }
       classElement.accessors = memberHolder.accessors;
       classElement.fields = memberHolder.fields;
       classElement.methods = memberHolder.methods;
       correspondingType.typeArguments =
@@ skipping 26 matching lines @@
 
   /**
    * Resynthesize a [ConstructorElement] and place it in the given [holder].
    */
   void buildConstructor(
       UnlinkedExecutable serializedExecutable, ElementHolder holder) {
     assert(serializedExecutable.kind == UnlinkedExecutableKind.constructor);
     ConstructorElementImpl constructorElement =
         new ConstructorElementImpl(serializedExecutable.name, -1);
     buildExecutableCommonParts(constructorElement, serializedExecutable);
-    if (serializedExecutable.isFactory) {
-      constructorElement.setModifier(Modifier.FACTORY, true);
-    }
-    if (serializedExecutable.isConst) {
-      constructorElement.setModifier(Modifier.CONST, true);
-    }
+    constructorElement.factory = serializedExecutable.isFactory;
+    constructorElement.const2 = serializedExecutable.isConst;
     holder.addConstructor(constructorElement);
   }
 
   /**
    * Resynthesize the [ClassElement] corresponding to an enum, along with the
    * associated fields and implicit accessors.
    */
   void buildEnum(UnlinkedEnum serializedEnum) {
     // TODO(paulberry): add offset support (for this element type and others)
     ClassElementImpl classElement =
         new ClassElementImpl(serializedEnum.name, -1);
-    classElement.setModifier(Modifier.ENUM, true);
+    classElement.enum2 = true;
     InterfaceType enumType = new InterfaceTypeImpl(classElement);
     classElement.type = enumType;
     classElement.supertype = summaryResynthesizer.typeProvider.objectType;
     ElementHolder memberHolder = new ElementHolder();
     FieldElementImpl indexField = new FieldElementImpl('index', -1);
-    indexField.setModifier(Modifier.FINAL, true);
-    indexField.setModifier(Modifier.SYNTHETIC, true);
+    indexField.final2 = true;
+    indexField.synthetic = true;
     indexField.type = summaryResynthesizer.typeProvider.intType;
     memberHolder.addField(indexField);
     buildImplicitAccessors(indexField, memberHolder);
     FieldElementImpl valuesField = new ConstFieldElementImpl('values', -1);
-    valuesField.setModifier(Modifier.SYNTHETIC, true);
-    valuesField.setModifier(Modifier.CONST, true);
-    valuesField.setModifier(Modifier.STATIC, true);
+    valuesField.synthetic = true;
+    valuesField.const3 = true;
+    valuesField.static = true;
     valuesField.type = summaryResynthesizer.typeProvider.listType
         .substitute4(<DartType>[enumType]);
     memberHolder.addField(valuesField);
     buildImplicitAccessors(valuesField, memberHolder);
     for (UnlinkedEnumValue serializedEnumValue in serializedEnum.values) {
       ConstFieldElementImpl valueField =
           new ConstFieldElementImpl(serializedEnumValue.name, -1);
-      valueField.setModifier(Modifier.CONST, true);
-      valueField.setModifier(Modifier.STATIC, true);
+      valueField.const3 = true;
+      valueField.static = true;
       valueField.type = enumType;
       memberHolder.addField(valueField);
       buildImplicitAccessors(valueField, memberHolder);
     }
     classElement.fields = memberHolder.fields;
     classElement.accessors = memberHolder.accessors;
     classElement.constructors = <ConstructorElement>[];
     unitHolder.addEnum(classElement);
   }
 
@@ skipping 14 matching lines @@
     switch (kind) {
       case UnlinkedExecutableKind.functionOrMethod:
         if (isTopLevel) {
           FunctionElementImpl executableElement =
               new FunctionElementImpl(name, -1);
           buildExecutableCommonParts(executableElement, serializedExecutable);
           holder.addFunction(executableElement);
         } else {
           MethodElementImpl executableElement = new MethodElementImpl(name, -1);
           buildExecutableCommonParts(executableElement, serializedExecutable);
-          executableElement.setModifier(
-              Modifier.STATIC, serializedExecutable.isStatic);
+          executableElement.static = serializedExecutable.isStatic;
           holder.addMethod(executableElement);
         }
         break;
       case UnlinkedExecutableKind.getter:
       case UnlinkedExecutableKind.setter:
         PropertyAccessorElementImpl executableElement =
             new PropertyAccessorElementImpl(name, -1);
         if (isTopLevel) {
-          executableElement.setModifier(Modifier.STATIC, true);
+          executableElement.static = true;
         } else {
-          executableElement.setModifier(
-              Modifier.STATIC, serializedExecutable.isStatic);
+          executableElement.static = serializedExecutable.isStatic;
         }
         buildExecutableCommonParts(executableElement, serializedExecutable);
         DartType type;
         if (kind == UnlinkedExecutableKind.getter) {
-          executableElement.setModifier(Modifier.GETTER, true);
+          executableElement.getter = true;
           type = executableElement.returnType;
         } else {
-          executableElement.setModifier(Modifier.SETTER, true);
+          executableElement.setter = true;
           type = executableElement.parameters[0].type;
         }
         holder.addAccessor(executableElement);
         // TODO(paulberry): consider removing implicit variables from the
         // element model; the spec doesn't call for them, and they cause
         // trouble when getters/setters exist in different parts.
         PropertyInducingElementImpl implicitVariable;
         if (isTopLevel) {
           implicitVariable = buildImplicitTopLevelVariable(name, kind, holder);
         } else {
-          implicitVariable = buildImplicitField(name, type, kind, holder);
-          implicitVariable.setModifier(
-              Modifier.STATIC, serializedExecutable.isStatic);
+          FieldElementImpl field = buildImplicitField(name, type, kind, holder);
+          field.static = serializedExecutable.isStatic;
+          implicitVariable = field;
         }
         executableElement.variable = implicitVariable;
         if (kind == UnlinkedExecutableKind.getter) {
           implicitVariable.getter = executableElement;
         } else {
           implicitVariable.setter = executableElement;
         }
         // TODO(paulberry): do the right thing when getter and setter are in
         // different units.
         break;
@@ skipping 12 matching lines @@
   void buildExecutableCommonParts(ExecutableElementImpl executableElement,
       UnlinkedExecutable serializedExecutable) {
     executableElement.parameters =
         serializedExecutable.parameters.map(buildParameter).toList();
     if (serializedExecutable.returnType != null) {
       executableElement.returnType = buildType(serializedExecutable.returnType);
     } else {
       executableElement.returnType = VoidTypeImpl.instance;
     }
     executableElement.type = new FunctionTypeImpl(executableElement);
-    if (serializedExecutable.hasImplicitReturnType) {
-      executableElement.setModifier(Modifier.IMPLICIT_TYPE, true);
-    }
+    executableElement.hasImplicitReturnType =
+        serializedExecutable.hasImplicitReturnType;
   }
 
   /**
    * Resynthesize an [ExportElement],
    */
   ExportElement buildExport(UnlinkedExport serializedExport) {
     ExportElementImpl exportElement = new ExportElementImpl(0);
     String exportedLibraryUri = summaryResynthesizer.sourceFactory
         .resolveUri(librarySource, serializedExport.uri)
         .uri
         .toString();
     exportElement.exportedLibrary = new LibraryElementHandle(
         summaryResynthesizer,
         new ElementLocationImpl.con3(<String>[exportedLibraryUri]));
     exportElement.uri = serializedExport.uri;
     exportElement.combinators =
         serializedExport.combinators.map(buildCombinator).toList();
     return exportElement;
   }
 
   /**
    * Resynthesize a [FieldElement].
    */
   FieldElement buildField(UnlinkedVariable serializedField) {
     FieldElementImpl fieldElement =
         new FieldElementImpl(serializedField.name, -1);
     fieldElement.type = buildType(serializedField.type);
-    if (serializedField.isConst) {
-      fieldElement.setModifier(Modifier.CONST, true);
-    }
+    fieldElement.const3 = serializedField.isConst;
     return fieldElement;
   }
 
   /**
    * Build the implicit getter and setter associated with [element], and place
    * them in [holder].
    */
   void buildImplicitAccessors(
       PropertyInducingElementImpl element, ElementHolder holder) {
     String name = element.name;
     DartType type = element.type;
     PropertyAccessorElementImpl getter =
         new PropertyAccessorElementImpl(name, -1);
-    getter.setModifier(Modifier.GETTER, true);
-    getter.setModifier(Modifier.STATIC, element.isStatic);
-    getter.setModifier(Modifier.SYNTHETIC, true);
+    getter.getter = true;
+    getter.static = element.isStatic;
+    getter.synthetic = true;
     getter.returnType = type;
     getter.type = new FunctionTypeImpl(getter);
     getter.variable = element;
     holder.addAccessor(getter);
     element.getter = getter;
     if (!(element.isConst || element.isFinal)) {
       PropertyAccessorElementImpl setter =
           new PropertyAccessorElementImpl(name, -1);
-      setter.setModifier(Modifier.SETTER, true);
-      setter.setModifier(Modifier.STATIC, element.isStatic);
-      setter.setModifier(Modifier.SYNTHETIC, true);
+      setter.setter = true;
+      setter.static = element.isStatic;
+      setter.synthetic = true;
       setter.parameters = <ParameterElement>[
         new ParameterElementImpl('_$name', -1)
-          ..setModifier(Modifier.SYNTHETIC, true)
+          ..synthetic = true
           ..type = type
           ..parameterKind = ParameterKind.REQUIRED
       ];
       setter.returnType = VoidTypeImpl.instance;
       setter.type = new FunctionTypeImpl(setter);
       setter.variable = element;
       holder.addAccessor(setter);
       element.setter = setter;
     }
   }
 
   /**
    * Build the implicit field associated with a getter or setter, and place it
    * in [holder].
    */
-  PropertyInducingElementImpl buildImplicitField(String name, DartType type,
+  FieldElementImpl buildImplicitField(String name, DartType type,
       UnlinkedExecutableKind kind, ElementHolder holder) {
     if (holder.getField(name) == null) {
       FieldElementImpl field = new FieldElementImpl(name, -1);
-      field.setModifier(Modifier.SYNTHETIC, true);
-      if (kind == UnlinkedExecutableKind.getter) {
-        field.setModifier(Modifier.FINAL, true);
-      }
+      field.synthetic = true;
+      field.final2 = kind == UnlinkedExecutableKind.getter;
       field.type = type;
       holder.addField(field);
       return field;
     } else {
       // TODO(paulberry): if adding a setter where there was previously
       // only a getter, remove "final" modifier.
       // TODO(paulberry): what if the getter and setter have a type mismatch?
       throw new UnimplementedError();
     }
   }
 
   /**
    * Build the implicit top level variable associated with a getter or setter,
    * and place it in [holder].
    */
   PropertyInducingElementImpl buildImplicitTopLevelVariable(
       String name, UnlinkedExecutableKind kind, ElementHolder holder) {
     if (holder.getTopLevelVariable(name) == null) {
       TopLevelVariableElementImpl variable =
           new TopLevelVariableElementImpl(name, -1);
-      variable.setModifier(Modifier.SYNTHETIC, true);
-      if (kind == UnlinkedExecutableKind.getter) {
-        variable.setModifier(Modifier.FINAL, true);
-      }
+      variable.synthetic = true;
+      variable.final2 = kind == UnlinkedExecutableKind.getter;
       holder.addTopLevelVariable(variable);
       return variable;
     } else {
       // TODO(paulberry): if adding a setter where there was previously
       // only a getter, remove "final" modifier.
       // TODO(paulberry): what if the getter and setter have a type mismatch?
       throw new UnimplementedError();
     }
   }
 
   /**
    * Resynthesize an [ImportElement].
    */
   ImportElement buildImport(UnlinkedImport serializedImport, int dependency) {
     bool isSynthetic = serializedImport.isImplicit;
     // TODO(paulberry): it seems problematic for the offset to be 0 for
     // non-synthetic imports, since it is used to disambiguate location.
     ImportElementImpl importElement =
         new ImportElementImpl(isSynthetic ? -1 : serializedImport.offset);
     String absoluteUri = summaryResynthesizer.sourceFactory
         .resolveUri(
             librarySource, prelinkedLibrary.dependencies[dependency].uri)
         .uri
         .toString();
     importElement.importedLibrary = new LibraryElementHandle(
         summaryResynthesizer,
         new ElementLocationImpl.con3(<String>[absoluteUri]));
     if (isSynthetic) {
-      importElement.setModifier(Modifier.SYNTHETIC, true);
+      importElement.synthetic = true;
     } else {
       importElement.uri = serializedImport.uri;
     }
     if (serializedImport.prefixReference != 0) {
       UnlinkedReference serializedPrefix = prelinkedLibrary.units[0]
           .unlinked
           .references[serializedImport.prefixReference];
       importElement.prefix = new PrefixElementImpl(serializedPrefix.name, -1);
     }
     importElement.combinators =
@@ skipping 44 matching lines @@
 
   /**
    * Resynthesize a [ParameterElement].
    */
   ParameterElement buildParameter(UnlinkedParam serializedParameter) {
     ParameterElementImpl parameterElement =
         new ParameterElementImpl(serializedParameter.name, -1);
     if (serializedParameter.isFunctionTyped) {
       FunctionElementImpl parameterTypeElement =
           new FunctionElementImpl('', -1);
-      parameterTypeElement.setModifier(Modifier.SYNTHETIC, true);
+      parameterTypeElement.synthetic = true;
       parameterElement.parameters =
           serializedParameter.parameters.map(buildParameter).toList();
       parameterTypeElement.enclosingElement = parameterElement;
       parameterTypeElement.shareParameters(parameterElement.parameters);
       if (serializedParameter.type != null) {
         parameterTypeElement.returnType = buildType(serializedParameter.type);
       } else {
         parameterTypeElement.returnType = VoidTypeImpl.instance;
       }
       parameterElement.type = new FunctionTypeImpl(parameterTypeElement);
     } else {
       parameterElement.type = buildType(serializedParameter.type);
-      if (serializedParameter.hasImplicitType) {
-        parameterElement.setModifier(Modifier.IMPLICIT_TYPE, true);
-      }
+      parameterElement.hasImplicitType = serializedParameter.hasImplicitType;
     }
     switch (serializedParameter.kind) {
       case UnlinkedParamKind.named:
         parameterElement.parameterKind = ParameterKind.NAMED;
         break;
       case UnlinkedParamKind.positional:
         parameterElement.parameterKind = ParameterKind.POSITIONAL;
         break;
       case UnlinkedParamKind.required:
         parameterElement.parameterKind = ParameterKind.REQUIRED;
@@ skipping 162 matching lines @@
     if (holder == null) {
       TopLevelVariableElementImpl element =
           new TopLevelVariableElementImpl(serializedVariable.name, -1);
       buildVariableCommonParts(element, serializedVariable);
       unitHolder.addTopLevelVariable(element);
       buildImplicitAccessors(element, unitHolder);
     } else {
       FieldElementImpl element =
           new FieldElementImpl(serializedVariable.name, -1);
       buildVariableCommonParts(element, serializedVariable);
+      element.static = serializedVariable.isStatic;
       holder.addField(element);
       buildImplicitAccessors(element, holder);
     }
   }
 
   /**
    * Handle the parts that are common to top level variables and fields.
    */
   void buildVariableCommonParts(PropertyInducingElementImpl element,
       UnlinkedVariable serializedVariable) {
     element.type = buildType(serializedVariable.type);
-    element.setModifier(Modifier.CONST, serializedVariable.isConst);
-    element.setModifier(Modifier.STATIC, serializedVariable.isStatic);
+    element.const3 = serializedVariable.isConst;
   }
 
   /**
    * Finish creating a [TypeParameterElement] by deserializing its bound.
    */
   void finishTypeParameter(UnlinkedTypeParam serializedTypeParameter,
       TypeParameterElementImpl typeParameterElement) {
     if (serializedTypeParameter.bound != null) {
       typeParameterElement.bound = buildType(serializedTypeParameter.bound);
     }
@@ skipping 33 matching lines @@
       elementMap[cls.name] = cls;
     }
     for (FunctionTypeAliasElement typeAlias in unit.functionTypeAliases) {
       elementMap[typeAlias.name] = typeAlias;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     prelinkedUnit = null;
   }
 }