Implement initializer asserts.

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

 // Copyright (c) 2016, 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 fasta.body_builder;
 
 import '../fasta_codes.dart'
     show FastaMessage, codeExpectedButGot, codeExpectedFunctionBody;
 
-import '../parser/parser.dart' show FormalParameterType, MemberKind, optional;
+import '../parser/parser.dart'
+    show Assert, FormalParameterType, MemberKind, optional;
 
 import '../parser/identifier_context.dart' show IdentifierContext;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
 
 import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
 
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart'
     show TypeInferrer;
 
@@ skipping 78 matching lines @@
   ///
   /// 1. if the current class is Object,
   /// 2. if there is an explicit super initializer,
   /// 3. if there is a redirecting (this) initializer, or
   /// 4. if a compile-time error prevented us from generating code for an
   ///    initializer. This avoids cascading errors.
   bool needsImplicitSuperInitializer;
 
   Scope formalParameterScope;
 
+  /// This is set to true when we start parsing an initializer. We use this to
+  /// find the correct scope for initializers like in this example:
+  ///
+  ///     class C {
+  ///       final x;
+  ///       C(x) : x = x;
+  ///     }
+  ///
+  /// When parsing this initializer `x = x`, `x` must be resolved in two
+  /// different scopes. The first `x` must be resolved in the class' scope, the
+  /// second in the formal parameter scope.
   bool inInitializer = false;
 
   bool inCatchClause = false;
 
   bool inCatchBlock = false;
 
   int functionNestingLevel = 0;
 
   Statement compileTimeErrorInTry;
 
@@ skipping 2323 matching lines @@
     exitLoopOrSwitch(result);
   }
 
   @override
   void handleEmptyStatement(Token token) {
     debugEvent("EmptyStatement");
     push(new EmptyStatement());
   }
 
   @override
-  void handleAssertStatement(Token assertKeyword, Token leftParenthesis,
-      Token commaToken, Token rightParenthesis, Token semicolonToken) {
-    debugEvent("AssertStatement");
-    Expression message = popForValueIfNotNull(commaToken);
-    Expression condition = popForValue();
-    push(new AssertStatement(condition, message));
+  void beginAssert(Token assertKeyword, Assert kind) {
+    debugEvent("beginAssert");
+    // If in an assert initializer, make sure [inInitializer] is false so we
+    // use the formal parameter scope. If this is any other kind of assert,
+    // inInitializer should be false anyway.
+    inInitializer = false;
   }
 
   @override
+  void endAssert(Token assertKeyword, Assert kind, Token leftParenthesis,
+      Token commaToken, Token rightParenthesis, Token semicolonToken) {
+    debugEvent("Assert");
+    Expression message = popForValueIfNotNull(commaToken);
+    Expression condition = popForValue();
+    AssertStatement statement = new AssertStatement(condition, message);
+    switch (kind) {
+      case Assert.Statement:
+        push(statement);
+        break;
+
+      case Assert.Expression:
+        push(buildCompileTimeError("`assert` can't be used as an expression."));
+        break;
+
+      case Assert.Initializer:
+        push(buildAssertInitializer(statement));
+        break;
+    }
+  }
+
+  Initializer buildAssertInitializer(AssertStatement statement) {
+    // Since kernel only has asserts in statment form, we convert it to an
+    // expression by wrapping it in an anonymous function which we call
+    // immediately.
+    //
+    // Additionally, kernel has no initializer that evaluates an expression,
+    // but it does have `LocalInitializer` which requires a variable declartion.
+    //
+    // So we produce an initializer like this:
+    //
+    //    var #t0 = (() { statement; }) ()
+    return new LocalInitializer(new VariableDeclaration.forValue(
+        buildMethodInvocation(
+            new FunctionExpression(new FunctionNode(statement)),
+            callName,
+            new Arguments.empty(),
+            statement.fileOffset,
+            isConstantExpression: true,
+            isImplicitCall: true)));
+  }
+
+  @override
   void endYieldStatement(Token yieldToken, Token starToken, Token endToken) {
     debugEvent("YieldStatement");
     push(new KernelYieldStatement(popForValue(), isYieldStar: starToken != null)
       ..fileOffset = yieldToken.charOffset);
   }
 
   @override
   void beginSwitchBlock(Token token) {
     debugEvent("beginSwitchBlock");
     enterLocalScope();
@@ skipping 951 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }