Add optional message to assert in Dart2js - continued

pkg/compiler/lib/src/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.
 
 library dart2js.resolution.members;
 
 import '../common/names.dart' show
     Selectors;
 import '../compiler.dart' show
     Compiler;
@@ skipping 481 matching lines @@
             compiler.resolver.constantCompiler.compileConstant(parameter);
       });
     });
     if (inCheckContext) {
       functionParameters.forEachParameter((ParameterElement element) {
         registry.registerIsCheck(element.type);
       });
     }
   }
 
+  ResolutionResult visitAssert(Assert node) {
+    // TODO(sra): We could completely ignore the assert in production mode if we
+    // didn't need it to be resolved for type checking.
+    registry.registerAssert(node.hasMessage);
+    visit(node.condition);
+    visit(node.message);

[Johnni Winther, 2015/09/16 16:48:38]

The fastest way is the add an option like in
https://codereview.chromium.org/1346943003 and then check here that
[node.message] is `null` if the feature is not enabled.

[sra1, 2015/09/16 17:33:29]

I will do this under a separate CL.
A separate CL will help with removing the flag.

+    return const NoneResult();
+  }
+
   ResolutionResult visitCascade(Cascade node) {
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitCascadeReceiver(CascadeReceiver node) {
     visit(node.expression);
     return const NoneResult();
   }
 
@@ skipping 1007 matching lines @@
     Selector selector = callStructure.callSelector;
     // TODO(23998): Remove this when all information goes through the
     // [SendStructure].
     registry.setSelector(node, selector);
     registry.registerDynamicInvocation(new UniverseSelector(selector, null));
     registry.registerSendStructure(node,
         new InvokeStructure(const DynamicAccess.expression(), selector));
     return const NoneResult();
   }
 
-  /// Handle a, possibly invalid, assertion, like `assert(cond)` or `assert()`.
-  ResolutionResult handleAssert(Send node) {
-    assert(invariant(node, node.isCall,
-        message: "Unexpected assert: $node"));
-    // If this send is of the form "assert(expr);", then
-    // this is an assertion.
-
-    CallStructure callStructure =
-        resolveArguments(node.argumentsNode).callStructure;
-    SendStructure sendStructure = const AssertStructure();
-    if (callStructure.argumentCount != 1) {
-      compiler.reportError(
-          node.selector,
-          MessageKind.WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT,
-          {'argumentCount': callStructure.argumentCount});
-      sendStructure = const InvalidAssertStructure();
-    } else if (callStructure.namedArgumentCount != 0) {
-      compiler.reportError(
-          node.selector,
-          MessageKind.ASSERT_IS_GIVEN_NAMED_ARGUMENTS,
-          {'argumentCount': callStructure.namedArgumentCount});
-      sendStructure = const InvalidAssertStructure();
-    }
-    registry.registerAssert(node);
-    registry.registerSendStructure(node, sendStructure);
-    return const AssertResult();
-  }
-
   /// Handle access of a property of [name] on `this`, like `this.name` and
   /// `this.name()`, or `name` and `name()` in instance context.
   ResolutionResult handleThisPropertyAccess(Send node, Name name) {
     AccessSemantics semantics = new DynamicAccess.thisProperty(name);
     return handleDynamicAccessSemantics(node, name, semantics);
   }
 
   /// Handle update of a property of [name] on `this`, like `this.name = b` and
   /// `this.name++`, or `name = b` and `name++` in instance context.
   ResolutionResult handleThisPropertyUpdate(
@@ skipping 1457 matching lines @@
 
   /// Handle an unqualified [Send], that is where the `node.receiver` is null,
   /// like `a`, `a()`, `this()`, `assert()`, and `(){}()`.
   ResolutionResult handleUnqualifiedSend(Send node) {
     Identifier selector = node.selector.asIdentifier();
     if (selector == null) {
       // `(){}()` and `(foo)()`.
       return handleExpressionInvoke(node);
     }
     String text = selector.source;
-    if (text == 'assert') {
-      // `assert()`.
-      return handleAssert(node);
-    } else if (text == 'this') {
+    if (text == 'this') {
       // `this()`.
       return handleThisAccess(node);
     }
     // `name` or `name()`
     Name name = new Name(text, enclosingElement.library);
     Element element = lookupInScope(compiler, node, scope, text);
     if (element == null) {
       if (text == 'dynamic') {
         // `dynamic` or `dynamic()` where 'dynamic' is not declared in the
         // current scope.
@@ skipping 1620 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }