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 131 matching lines @@
 
     // If the name could not be deconstructed, this is is from a
     // factory method from a deprecated interface implementation.
     if (name == null) return;
 
     Element otherMember = holder.lookupLocalMember(name);
     if (otherMember != null) {
       if (compiler.onDeprecatedFeature(member, 'conflicting constructor')) {
         compiler.reportMessage(
             compiler.spanFromElement(otherMember),
+            // Using GENERIC as this message is temporary.
             MessageKind.GENERIC.error({'text': 'This member conflicts with a'
                                                ' constructor.'}),
             Diagnostic.INFO);
       }
     }
   }
 
   void checkAbstractField(Element member) {
     // Only check for getters. The test can only fail if there is both a setter
     // and a getter with the same name, and we only need to check each abstract
@@ skipping 903 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 343 matching lines @@
     }
 
     var oldCategory = allowedCategory;
     allowedCategory |= ElementCategory.PREFIX | ElementCategory.SUPER;
     Element resolvedReceiver = visit(node.receiver);
     allowedCategory = oldCategory;
 
     Element target;
     SourceString name = node.selector.asIdentifier().source;
     if (identical(name.stringValue, 'this')) {
+      // TODO(ahe): Why is this using GENERIC?
       error(node.selector, MessageKind.GENERIC,
             {'text': "expected an identifier"});
     } else if (node.isSuperCall) {
       if (node.isOperator) {
         if (isUserDefinableOperator(name.stringValue)) {
           name = selector.name;
         } else {
           error(node.selector, MessageKind.ILLEGAL_SUPER_SEND, {'name': name});
         }
       }
@@ skipping 160 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.STATIC_FUNCTION_BLOAT,
+          {'class': compiler.mirrorSystemClass.name,
+           'name': compiler.mirrorSystemGetNameFunction.name});
+    }
+
     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.
+      assert(invariant(node, compiler.symbolValidatedConstructor != null));
+      world.registerStaticUse(compiler.symbolValidatedConstructor);
+    }
   }
 
   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) {
+      compiler.reportWarningCode(
+          node.newToken, MessageKind.NON_CONST_BLOAT,
+          {'name': compiler.symbolClass.name});
+    }
     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()) {
+        DartType type = name.computeType(compiler);
+        compiler.reportErrorCode(argumentNode, MessageKind.STRING_EXPECTED,
+                                 {'type': type});
+      } 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.PRIVATE_IDENTIFIER,
+                               {'value': name});
+      return;
+    }
+    if (!symbolValidationPattern.hasMatch(name)) {
+      compiler.reportErrorCode(node, MessageKind.INVALID_SYMBOL,
+                               {'value': name});
+    }
+  }
+
+
   /**
    * 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);
   }
 }