Implement invoke, setField, and getField (unminified).

dart/sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 1535 matching lines @@
   Element get enclosingElement;
   /// The current scope of the visitor.
   Scope get scope;
 
   MappingVisitor(Compiler compiler, TreeElementMapping this.mapping)
       : typeResolver = new TypeResolver(compiler),
         super(compiler);
 
   Element useElement(Node node, Element element) {
     if (element == null) return null;
-    return mapping[node] = element;
+    return mapping[node] = element.declaration;

[Johnni Winther, 2013/05/08 08:22:08]

I'm not sure this works with the current invariant for patch library accesses.
What problems have you experienced with this?

[ahe, 2013/05/08 08:57:43]

Good you spotted this, then.  The problem is that a use of "reflectClass"
resolved to the implementation in mirrors_patch.dart.  I think I know how to
work around this problem and can file a bug we can look at later.

   }
 
   DartType useType(TypeAnnotation annotation, DartType type) {
     if (type != null) {
       mapping.setType(annotation, type);
       useElement(annotation, type.element);
     }
     return type;
   }
 }
@@ skipping 925 matching lines @@
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = false;
     visit(node.expression);
     sendIsMemberAccess = oldSendIsMemberAccess;
   }
 
   visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
     FunctionElement constructor = resolveConstructor(node);
     final bool isSymbolConstructor = constructor == compiler.symbolConstructor;
-    if (!node.isConst() && isSymbolConstructor) {
-      compiler.reportWarningCode(
-          node.newToken, MessageKind.NON_CONST_BLOAT,
-          {'name': compiler.symbolClass.name});
-    }
     resolveSelector(node.send, constructor);
     resolveArguments(node.send.argumentsNode);
     useElement(node.send, constructor);
     if (Elements.isUnresolved(constructor)) return constructor;
     Selector callSelector = mapping.getSelector(node.send);
     if (!callSelector.applies(constructor, compiler)) {
       warnArgumentMismatch(node.send, constructor);
       compiler.backend.registerThrowNoSuchMethod(mapping);
     }
 
@@ skipping 11 matching lines @@
     }
     // [cls] might be the declaration element and we want to include injected
     // members.
     cls.implementation.forEachInstanceField(
         (ClassElement enclosingClass, Element member) {
           world.addToWorkList(member);
         },
         includeBackendMembers: false,
         includeSuperMembers: true);
 
-    if (node.isConst() && isSymbolConstructor) {
-      Node argumentNode = node.send.arguments.head;
-      Constant name = compiler.metadataHandler.compileNodeWithDefinitions(
-          argumentNode, mapping, isConst: true);
-      if (!name.isString()) {
-        DartType type = name.computeType(compiler);
-        compiler.reportErrorCode(argumentNode, MessageKind.STRING_EXPECTED,
-                                 {'type': type});
+    if (isSymbolConstructor) {
+      if (node.isConst()) {
+        Node argumentNode = node.send.arguments.head;
+        Constant name = compiler.metadataHandler.compileNodeWithDefinitions(
+            argumentNode, mapping, isConst: true);
+        if (!name.isString()) {
+          DartType type = name.computeType(compiler);
+          compiler.reportErrorCode(argumentNode, MessageKind.STRING_EXPECTED,
+                                   {'type': type});
+        } else {
+          StringConstant stringConstant = name;
+          String nameString = stringConstant.toDartString().slowToString();
+          if (validateSymbol(argumentNode, nameString)) {
+            world.registerConstSymbol(nameString, mapping);
+          }
+        }
       } else {
-        StringConstant stringConstant = name;
-        validateSymbol(argumentNode,
-                       stringConstant.toDartString().slowToString());
+        compiler.reportWarningCode(
+            node.newToken, MessageKind.NON_CONST_BLOAT,
+            {'name': compiler.symbolClass.name});
+        world.registerNewSymbol(mapping);
       }
     }
 
     return null;
   }
 
-  void validateSymbol(Node node, String name) {
-    if (name.isEmpty) return;
+  bool validateSymbol(Node node, String name) {
+    if (name.isEmpty) return true;
     if (name.startsWith('_')) {
       compiler.reportErrorCode(node, MessageKind.PRIVATE_IDENTIFIER,
                                {'value': name});
-      return;
+      return false;
     }
     if (!symbolValidationPattern.hasMatch(name)) {
       compiler.reportErrorCode(node, MessageKind.INVALID_SYMBOL,
                                {'value': name});
+      return false;
     }
+    return true;
   }
 
 
   /**
    * Try to resolve the constructor that is referred to by [node].
    * Note: this function may return an ErroneousFunctionElement instead of
    * [null], if there is no corresponding constructor, class or library.
    */
   FunctionElement resolveConstructor(NewExpression node) {
     return node.accept(new ConstructorResolver(compiler, this));
@@ skipping 1326 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }