Fix some issues in element serialization.

pkg/compiler/lib/src/serialization/modelz.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.
 
 /// Implementation of the element model used for deserialiation.
 ///
 /// These classes are created by [ElementDeserializer] triggered by the
 /// [Deserializer].
 
 library dart2js.serialization.modelz;
@@ skipping 62 matching lines @@
     return _unsupported('enclosingClassOrCompilationUnit');
   }
 
   @override
   LibraryElement get implementationLibrary => library;
 
   @override
   bool get isAbstract => false;
 
   @override
-  bool get isAssignable => _unsupported('isAssignable');
-
-  @override
   bool get isClassMember => false;
 
   @override
   bool get isClosure => _unsupported('isClosure');
 
   @override
   bool get isConst => _unsupported('isConst');
 
   @override
   bool get isDeferredLoaderGetter => false;
@@ skipping 21 matching lines @@
   bool get isSynthesized => true;
 
   @override
   bool get isTopLevel => false;
 
   // TODO(johnniwinther): Support metadata.
   @override
   Iterable<MetadataAnnotation> get metadata => const <MetadataAnnotation>[];
 
   @override
-  Element get outermostEnclosingMemberOrTopLevel {
-    return _unsupported('outermostEnclosingMemberOrTopLevel');
-  }
-
-  @override
   Token get position => _unsupported('position');
 }
 
 abstract class DeserializedElementZ extends ElementZ {
   ObjectDecoder _decoder;
 
   DeserializedElementZ(this._decoder);
 
   @override
   String get name => _decoder.getString(Key.NAME);
@@ skipping 521 matching lines @@
   FunctionSignature get functionSignature {
     if (_functionSignature == null) {
       List<Element> requiredParameters = [];
       List<Element> optionalParameters = [];
       List orderedOptionalParameters = [];
       int requiredParameterCount = 0;
       int optionalParameterCount = 0;
       bool optionalParametersAreNamed = false;
       List<DartType> parameterTypes = <DartType>[];
       List<DartType> optionalParameterTypes = <DartType>[];
-      List<String> namedParameters = <String>[];
-      List<DartType> namedParameterTypes = <DartType>[];
       for (ParameterElement parameter in parameters) {
         if (parameter.isOptional) {
           optionalParameterCount++;
-          requiredParameters.add(parameter);
+          optionalParameters.add(parameter);
           orderedOptionalParameters.add(parameter);
           if (parameter.isNamed) {
             optionalParametersAreNamed = true;
-            namedParameters.add(parameter.name);
-            namedParameterTypes.add(parameter.type);
           } else {
             optionalParameterTypes.add(parameter.type);
           }
         } else {
           requiredParameterCount++;
-          optionalParameters.add(parameter);
+          requiredParameters.add(parameter);
           parameterTypes.add(parameter.type);
         }
       }
+      List<String> namedParameters = const <String>[];
+      List<DartType> namedParameterTypes = const <DartType>[];
       if (optionalParametersAreNamed) {
+        namedParameters = <String>[];
+        namedParameterTypes = <DartType>[];
         orderedOptionalParameters.sort((Element a, Element b) {
           return a.name.compareTo(b.name);
         });
+        for (ParameterElement parameter in orderedOptionalParameters) {
+          namedParameters.add(parameter.name);
+          namedParameterTypes.add(parameter.type);
+        }
       }
 
       FunctionType type = new FunctionType(
           this,
           _decoder.getType(Key.RETURN_TYPE),
           parameterTypes,
           optionalParameterTypes,
           namedParameters,
           namedParameterTypes);
       _functionSignature = new FunctionSignatureX(
@@ skipping 366 matching lines @@
       if (data == null) {
         assert(isFromEnvironmentConstructor || isExternal);
         return null;
       }
       _constantConstructor = ConstantConstructorDeserializer.deserialize(data);
     }
     return _constantConstructor;
   }
 
   @override
-  AsyncMarker get asyncMarker => _unsupported('asyncMarker');
+  AsyncMarker get asyncMarker => AsyncMarker.SYNC;
 
   @override
   InterfaceType computeEffectiveTargetType(InterfaceType newType) {
     return _unsupported('computeEffectiveTargetType');
   }
 
   @override
   ConstructorElement get definingConstructor {
     return _unsupported('definingConstructor');
   }
@@ skipping 243 matching lines @@
 
   @override
   ElementKind get kind => ElementKind.FUNCTION;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitMethodElement(this, arg);
   }
 
   @override
+  AsyncMarker get asyncMarker {
+    return _decoder.getEnum(Key.ASYNC_MARKER, AsyncMarker.values);
+  }
+
+  @override
   bool get isOperator => _decoder.getBool(Key.IS_OPERATOR);
 }
 
 class TopLevelFunctionElementZ extends FunctionElementZ
     with LibraryMemberMixin {
   TopLevelFunctionElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class StaticFunctionElementZ extends FunctionElementZ
     with ClassMemberMixin, StaticMemberMixin {
@@ skipping 74 matching lines @@
 
   GetterElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.GETTER;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitGetterElement(this, arg);
   }
+
+  @override
+  AsyncMarker get asyncMarker => AsyncMarker.SYNC;
 }
 
 class TopLevelGetterElementZ extends GetterElementZ with LibraryMemberMixin {
   TopLevelGetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class StaticGetterElementZ extends GetterElementZ
     with ClassMemberMixin, StaticMemberMixin {
   StaticGetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
@@ skipping 17 matching lines @@
 
   SetterElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.SETTER;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitSetterElement(this, arg);
   }
+
+  @override
+  AsyncMarker get asyncMarker => AsyncMarker.SYNC;
 }
 
 class TopLevelSetterElementZ extends SetterElementZ with LibraryMemberMixin {
   TopLevelSetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class StaticSetterElementZ extends SetterElementZ
     with ClassMemberMixin, StaticMemberMixin {
   StaticSetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
@@ skipping 211 matching lines @@
     return _bound;
   }
 
   @override
   LibraryElement get library => typeDeclaration.library;
 
   @override
   SourceSpan get sourcePosition => typeDeclaration.sourcePosition;
 }
 
-class ParameterElementZ extends DeserializedElementZ
+abstract class ParameterElementZ extends DeserializedElementZ
     with AnalyzableElementMixin, AstElementMixin, TypedElementMixin
     implements ParameterElement {
   FunctionElement _functionDeclaration;
   ConstantExpression _constant;
   DartType _type;
 
   ParameterElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
-  accept(ElementVisitor visitor, arg) {
-    return visitor.visitParameterElement(this, arg);
-  }
+  bool get isFinal => _decoder.getBool(Key.IS_FINAL);
+
+  @override
+  bool get isConst => false;
 
   @override
   ConstantExpression get constant {
     if (isOptional) {
       if (_constant == null) {
         _constant = _decoder.getConstant(Key.CONSTANT);
       }
       return _constant;
     }
     return null;
@@ skipping 24 matching lines @@
   @override
   Expression get initializer => _unsupported('initializer');
 
   @override
   bool get isNamed => _decoder.getBool(Key.IS_NAMED);
 
   @override
   bool get isOptional => _decoder.getBool(Key.IS_OPTIONAL);
 
   @override
-  ElementKind get kind => ElementKind.PARAMETER;
-
-  @override
   LibraryElement get library => executableContext.library;
 
   @override
   MemberElement get memberContext => executableContext.memberContext;
 }
 
+class LocalParameterElementZ extends ParameterElementZ
+    implements LocalParameterElement {
+  LocalParameterElementZ(ObjectDecoder decoder) : super(decoder);
+
+  @override
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitParameterElement(this, arg);
+  }
+
+  @override
+  ElementKind get kind => ElementKind.PARAMETER;
+}
+
 class InitializingFormalElementZ extends ParameterElementZ
     implements InitializingFormalElement {
   FieldElement _fieldElement;
 
   InitializingFormalElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   FieldElement get fieldElement {
     if (_fieldElement == null) {
       _fieldElement = _decoder.getElement(Key.FIELD);
@@ skipping 24 matching lines @@
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitLocalVariableElement(this, arg);
   }
 
   @override
   ElementKind get kind => ElementKind.VARIABLE;
 
   @override
+  bool get isFinal => _decoder.getBool(Key.IS_FINAL);
+
+  @override
   bool get isConst {
     if (_isConst == null) {
-      _constant = _decoder.getConstant(Key.CONSTANT);
+      _constant = _decoder.getConstant(Key.CONSTANT, isOptional: true);
       _isConst = _constant != null;
     }
     return _isConst;
   }
 
   @override
   ConstantExpression get constant {
     if (isConst) {
       return _constant;
     }
@@ skipping 134 matching lines @@
   }
 
   @override
   ElementKind get kind => ElementKind.PREFIX;
 
   @override
   Element lookupLocalMember(String memberName) {
     return _unsupported('lookupLocalMember');
   }
 }