Implement Symbol correctly in dart2js.

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 527 matching lines @@
       compiler.withCurrentElement(element, () => measure(() {
         assert(element.resolutionState == STATE_NOT_STARTED);
         element.resolutionState = STATE_STARTED;
         Node tree = element.parseNode(compiler);
         loadSupertypes(element, tree);
 
         ClassResolverVisitor visitor =
             new ClassResolverVisitor(compiler, element);
         visitor.visit(tree);
         element.resolutionState = STATE_DONE;
+        compiler.onClassResolved(element);
       }));
       if (element.isPatched) {
         // Ensure handling patch after origin.
         element.patch.ensureResolved(compiler);
       }
     } else { // Handle patch classes:
       element.resolutionState = STATE_STARTED;
       // Ensure handling origin before patch.
       element.origin.ensureResolved(compiler);
       // Ensure that the type is computed.
@@ skipping 1054 matching lines @@
   bool inCatchBlock;
   Scope scope;
   ClassElement currentClass;
   ExpressionStatement currentExpressionStatement;
   bool typeRequired = false;
   bool sendIsMemberAccess = false;
   StatementScope statementScope;
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION
       | ElementCategory.IMPLIES_TYPE;
 
+  // TODO(ahe): Find a way to share this with runtime implementation.
+  static final RegExp symbolValidationPattern =
+      new RegExp(r'^(?:[a-zA-Z$][a-zA-Z$0-9_]*\.)*(?:[a-zA-Z$][a-zA-Z$0-9_]*=?|'
+                 r'-|'
+                 r'unary-|'
+                 r'\[\]=|'
+                 r'~|'
+                 r'==|'
+                 r'\[\]|'
+                 r'\*|'
+                 r'/|'
+                 r'%|'
+                 r'~/|'
+                 r'\+|'
+                 r'<<|'
+                 r'>>|'
+                 r'>=|'
+                 r'>|'
+                 r'<=|'
+                 r'<|'
+                 r'&|'
+                 r'\^|'
+                 r'\|'
+                 r')$');
+
   ResolverVisitor(Compiler compiler, Element element, this.mapping)
     : this.enclosingElement = element,
       // When the element is a field, we are actually resolving its
       // initial value, which should not have access to instance
       // fields.
       inInstanceContext = (element.isInstanceMember() && !element.isField())
           || element.isGenerativeConstructor(),
       this.currentClass = element.isMember() ? element.getEnclosingClass()
                                              : null,
       this.statementScope = new StatementScope(),
@@ skipping 523 matching lines @@
       }
     }
   }
 
   visitSend(Send node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = node.isPropertyAccess || node.isCall;
     Element target = resolveSend(node);
     sendIsMemberAccess = oldSendIsMemberAccess;
 
+    if (target != null && target == compiler.mirrorSystemGetNameFunction) {
+      compiler.reportWarningCode(
+          node.selector, MessageKind.GENERIC,

[ahe, 2013/04/18 11:34:44]

Will provide real MessageKind before submitting.

+          {'text': 'Warning: using '
+              '"${compiler.mirrorSystemClass.name.slowToString()}.'
+              '${compiler.mirrorSystemGetNameFunction.name.slowToString()}" '
+              'will increase the size of compiled code.'});
+    }
+
     if (!Elements.isUnresolved(target)) {
       if (target.isAbstractField()) {
         AbstractFieldElement field = target;
         target = field.getter;
         if (target == null && !inInstanceContext) {
           compiler.backend.registerThrowNoSuchMethod(mapping);
           target =
               warnAndCreateErroneousElement(node.selector, field.name,
                                             MessageKind.CANNOT_RESOLVE_GETTER);
         }
@@ skipping 229 matching lines @@
 
   visitReturn(Return node) {
     if (node.isRedirectingFactoryBody) {
       handleRedirectingFactoryBody(node);
     } else {
       visit(node.expression);
     }
   }
 
   void handleRedirectingFactoryBody(Return node) {
+    final isSymbolConstructor = enclosingElement == compiler.symbolConstructor;
     if (!enclosingElement.isFactoryConstructor()) {
       compiler.reportErrorCode(
           node, MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY);
       compiler.reportErrorCode(
           enclosingElement, MessageKind.MISSING_FACTORY_KEYWORD);
     }
     Element redirectionTarget = resolveRedirectingFactory(node);
     var type = mapping.getType(node.expression);
     if (type is InterfaceType && !type.isRaw) {
       unimplemented(node.expression, 'type arguments on redirecting factory');
@@ skipping 14 matching lines @@
       FunctionElement targetImplementation = redirectionTarget.implementation;
       FunctionExpression function = targetImplementation.parseNode(compiler);
       if (function.body != null && function.body.asReturn() != null
           && function.body.asReturn().isRedirectingFactoryBody) {
         unimplemented(node.expression, 'redirecing to redirecting factory');
       }
     }
     world.registerStaticUse(redirectionTarget);
     world.registerInstantiatedClass(
         redirectionTarget.enclosingElement.declaration, mapping);
+    if (isSymbolConstructor) {
+      // Make sure that collection_dev.Symbol.validated is registered.
+      // TODO(ahe): Don't simply use head.

[ahe, 2013/04/18 11:34:44]

Will fix before submitting.

+      world.registerStaticUse(
+          redirectionTarget.enclosingElement.constructors.head);
+    }
   }
 
   visitThrow(Throw node) {
     if (!inCatchBlock && node.expression == null) {
       error(node, MessageKind.THROW_WITHOUT_EXPRESSION);
     }
     // We don't know ahead of time whether we will need the throw in a statement
     // context or an expression context, so we register both here, even though
     // we may not need ThrowExpression.
     compiler.backend.registerWrapException(mapping);
@@ skipping 25 matching lines @@
   visitParenthesizedExpression(ParenthesizedExpression node) {
     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) {
+      String name = compiler.symbolClass.name.slowToString();
+      compiler.reportWarningCode(
+          node.newToken, MessageKind.GENERIC,

[ahe, 2013/04/18 11:34:44]

Will provide real MessageKind before submitting.

+          {'text': 'Warning: using "new $name" will increase the size of '
+              'compiled code.  Use "const $name" if possible.'});
+    }
     resolveSelector(node.send);
     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);
     }
     compiler.withCurrentElement(constructor, () {
@@ skipping 22 matching lines @@
       compiler.backend.registerAbstractClassInstantiation(mapping);
     }
     // [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()) {
+        compiler.reportErrorCode(argumentNode, MessageKind.GENERIC,

[ahe, 2013/04/18 11:34:44]

Will provide real MessageKind before submitting.

+                                 {'text': 'Not a string'});
+      } else {
+        validateSymbol(argumentNode, name.toDartString().slowToString());
+      }
+    }
+
     return null;
   }
 
+  void validateSymbol(Node node, String name) {
+    if (name.isEmpty) return;
+    if (name.startsWith('_')) {
+      compiler.reportErrorCode(node, MessageKind.GENERIC,

[ahe, 2013/04/18 11:34:44]

Will provide real MessageKind before submitting.

+                               {'text': '"$name" is a private identifier.'});
+      return;
+    }
+    if (!symbolValidationPattern.hasMatch(name)) {
+      // TODO(ahe): Better error message.
+      compiler.reportErrorCode(
+          node, MessageKind.GENERIC,

[ahe, 2013/04/18 11:34:44]

Will provide real MessageKind before submitting.

+          {'text':
+            '"$name" must be a library name, operator name, or identifier.'});
+    }
+  }
+
+
   /**
    * 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));
   }
 
   FunctionElement resolveRedirectingFactory(Return node) {
@@ skipping 1329 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }