Make field-get/set work without elements.

lib/compiler/implementation/ssa/codegen.dart

 // Copyright (c) 2012, 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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name() => 'SSA code generator';
@@ skipping 1793 matching lines @@
     // Remove the element and 'this'.
     int argumentCount = node.inputs.length - 2;
     String className = compiler.namer.isolateAccess(superClass);
     if (superMethod.kind == ElementKind.FUNCTION ||
         superMethod.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
       String methodName = compiler.namer.instanceMethodName(
           currentLibrary, superMethod.name, argumentCount);
       buffer.add('$className.prototype.$methodName.call');
       visitArguments(node.inputs);
     } else if (superMethod.kind == ElementKind.FIELD) {
-      buffer.add('this.${compiler.namer.getName(superMethod)}');
+      ClassElement currentClass = work.element.enclosingElement;
+      if (currentClass.isShadowedByField(superMethod)) {
+        buffer.add('this.${compiler.namer.shadowedFieldName(superMethod)}');
+      } else {
+        LibraryElement library = superMethod.getLibrary();
+        SourceString name = superMethod.name;
+        buffer.add('this.${compiler.namer.instanceFieldName(library, name)}');
+      }
     } else {
       assert(superMethod.kind == ElementKind.GETTER ||
              superMethod.kind == ElementKind.SETTER);
       String methodName;
       if (superMethod.kind == ElementKind.GETTER) {
         methodName =
             compiler.namer.getterName(currentLibrary, superMethod.name);
       } else {
         methodName =
             compiler.namer.setterName(currentLibrary, superMethod.name);
       }
       buffer.add('$className.prototype.$methodName.call');
       visitArguments(node.inputs);
     }
     endExpression(JSPrecedence.CALL_PRECEDENCE);
     world.registerStaticUse(superMethod);
   }
 
   visitFieldGet(HFieldGet node) {
-    String name = compiler.namer.getName(node.element);
+    String name =
+        compiler.namer.instanceFieldName(node.libraryElement, node.fieldName);
     beginExpression(JSPrecedence.MEMBER_PRECEDENCE);
     use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.');
     buffer.add(name);
     beginExpression(JSPrecedence.MEMBER_PRECEDENCE);
     Type type = node.receiver.propagatedType.computeType(compiler);
     if (type != null) {
       world.registerFieldGetter(node.element.name, type);
     }
   }
@@ skipping 12 matching lines @@
   }
 
   visitFieldSet(HFieldSet node) {
     if (work.element.isGenerativeConstructorBody() &&
         node.element.enclosingElement.isClass() &&
         node.value.hasGuaranteedType() &&
         node.block.dominates(currentGraph.exit)) {
       backend.updateFieldConstructorSetters(node.element,
                                             node.value.guaranteedType);
     }
-    String name = compiler.namer.getName(node.element);
+    String name =
+        compiler.namer.instanceFieldName(node.libraryElement, node.fieldName);
     beginExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
     use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.');
     buffer.add(name);
     Type type = node.receiver.propagatedType.computeType(compiler);
     if (type != null) {
       if (!work.element.isGenerativeConstructorBody()) {
         world.registerFieldSetter(node.element.name, type);
       }
       // Determine the types seen so far for the field. If only number
@@ skipping 1301 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }