Roll sdk dependency to 34357cdad108dcba734949bd13bd28c76ea285e0

pkg/fletchc/lib/src/fletch_system_builder.dart

 // Copyright (c) 2015, the Fletch 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.md file.
 
 library fletchc.fletch_system_builder;
 
 import 'dart:typed_data';
 
 import 'package:compiler/src/constants/values.dart' show
     ConstantValue,
     ConstructedConstantValue,
     DeferredConstantValue,
     FunctionConstantValue,
     IntConstantValue,
     ListConstantValue,
     MapConstantValue,
     StringConstantValue;
 
 import 'package:compiler/src/elements/elements.dart' show
     ClassElement,
     ConstructorElement,
     Element,
+    FieldElement,
     FunctionElement,
-    FunctionSignature;
+    FunctionSignature,
+    MemberElement;
 
-import 'package:compiler/src/universe/universe.dart' show
+import 'package:compiler/src/universe/call_structure.dart' show
     CallStructure;
 
 import 'package:persistent/persistent.dart' show
     PersistentMap;
 
 import 'fletch_constants.dart' show
     FletchClassConstant,
     FletchFunctionConstant,
     FletchClassInstanceConstant;
 
@@ skipping 317 matching lines @@
     int changes = 0;
 
     // Remove all removed FletchFunctions.
     for (FletchFunction function in _removedFunctions) {
       commands.add(new RemoveFromMap(MapId.methods, function.functionId));
     }
 
     // Create all new FletchFunctions.
     List<FletchFunction> functions = <FletchFunction>[];
     for (FletchFunctionBuilder builder in _newFunctions) {
-      context.compiler.withCurrentElement(builder.element, () {
+      context.compiler.reporter.withCurrentElement(builder.element, () {
         functions.add(builder.finalizeFunction(context, commands));
       });
     }
 
     // Create all new FletchClasses.
     List<FletchClass> classes = <FletchClass>[];
     for (FletchClassBuilder builder in _newClasses.values) {
       classes.add(builder.finalizeClass(context, commands));
       changes++;
     }
@@ skipping 103 matching lines @@
         int tearoffId = lookupTearOffById(function.functionId);
         FletchFunctionBase tearoff = lookupFunction(tearoffId);
         commands
             ..add(new PushFromMap(MapId.classes, tearoff.memberOf))
             ..add(const PushNewInstance());
       } else if (constant.isConstructedObject) {
         ConstructedConstantValue value = constant;
         ClassElement classElement = value.type.element;
         // TODO(ajohnsen): Avoid usage of builders (should be FletchClass).
         FletchClassBuilder classBuilder = _classBuildersByElement[classElement];
-        for (ConstantValue field in value.fields.values) {
-          int fieldId = context.compiledConstants[field];
+
+        void addIfField(MemberElement member) {
+          if (!member.isField || member.isStatic || member.isPatch) return;
+          FieldElement fieldElement = member;
+          ConstantValue fieldValue = value.fields[fieldElement];
+          int fieldId = context.compiledConstants[fieldValue];
           commands.add(new PushFromMap(MapId.constants, fieldId));
         }
+
+        // Adds all the fields of [currentClass] in order starting from the top
+        // of the inheritance chain, and for each class adds non-patch fields
+        // before patch fields.
+        void addFields(ClassElement currentClass) {
+          if (currentClass.superclass != null) {
+            addFields(currentClass.superclass);
+          }
+          currentClass.forEachLocalMember(addIfField);

[ahe, 2015/11/17 16:44:09]

Why not forEachInstanceField?

[sigurdm, 2015/11/19 14:33:47]

forEachInstanceField has in the end calls forEachLocalMember via forEachMember
using a instancefilter, and a conditional on superAndInjected.
I thought this was simpler and more direct. But I'm happy to change it.

+          if (currentClass.isPatched) {
+            currentClass.patch.forEachLocalMember(addIfField);
+          }
+        }
+
+        addFields(classElement);
+
         commands
             ..add(new PushFromMap(MapId.classes, classBuilder.classId))
             ..add(const PushNewInstance());
       } else if (constant is FletchClassInstanceConstant) {
         commands
             ..add(new PushFromMap(MapId.classes, constant.classId))
             ..add(const PushNewInstance());
       } else if (constant.isType) {
         // TODO(kasperl): Implement proper support for class literals. At this
         // point, we've already issues unimplemented errors for the individual
@@ skipping 166 matching lines @@
         constructorInitializersByElement,
         tearoffsById,
         classesById,
         classesByElement,
         constants,
         symbolByFletchSelectorId,
         gettersByFieldIndex,
         settersByFieldIndex);
   }
 }