Various semantic checks regarding const and final.

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'
@@ skipping 392 matching lines @@
       Block block = popBlock(count, beginToken);
       exitLocalScope();
       push(block);
     }
   }
 
   void prepareInitializers() {
     ProcedureBuilder member = this.member;
     scope = member.computeFormalParameterInitializerScope(scope);
     if (member is KernelConstructorBuilder) {
+      if (member.isConst &&
+          (classBuilder.cls.superclass?.isMixinApplication ?? false)) {
+        addCompileTimeError(member.charOffset,
+            "Can't extend a mixin application and be 'const'.");
+      }
       if (member.formals != null) {
         for (KernelFormalParameterBuilder formal in member.formals) {
           if (formal.hasThis) {
             Initializer initializer;
             if (member.isExternal) {
               initializer = buildInvalidInitializer(
                   buildCompileTimeError(
                       "An external constructor can't initialize fields.",
                       formal.charOffset),
                   formal.charOffset);
@@ skipping 784 matching lines @@
   @override
   void endVariableInitializer(Token assignmentOperator) {
     debugEvent("VariableInitializer");
     assert(assignmentOperator.stringValue == "=");
     pushNewLocalVariable(popForValue(), equalsToken: assignmentOperator);
   }
 
   @override
   void handleNoVariableInitializer(Token token) {
     debugEvent("NoVariableInitializer");
-    pushNewLocalVariable(null);
+    bool isConst = (currentLocalVariableModifiers & constMask) != 0;
+    bool isFinal = (currentLocalVariableModifiers & finalMask) != 0;
+    Expression initializer;
+    if (!optional("in", token)) {
+      // A for-in loop-variable can't have an initializer. So let's remain
+      // silent if the next token is `in`. Since a for-in loop can only have
+      // one variable it must be followed by `in`.
+      if (isConst) {
+        initializer = buildCompileTimeError(
+            "A 'const' variable must be initialized.", token.charOffset);
+      } else if (isFinal) {
+        initializer = buildCompileTimeError(
+            "A 'final' variable must be initialized.", token.charOffset);
+      }
+    }
+    pushNewLocalVariable(initializer);
   }
 
   void pushNewLocalVariable(Expression initializer, {Token equalsToken}) {
     Identifier identifier = pop();
     assert(currentLocalVariableModifiers != -1);
     bool isConst = (currentLocalVariableModifiers & constMask) != 0;
     bool isFinal = (currentLocalVariableModifiers & finalMask) != 0;
     assert(isConst == constantExpressionRequired);
     push(new KernelVariableDeclaration(identifier.name, functionNestingLevel,
         initializer: initializer,
@@ skipping 746 matching lines @@
     List<TypeParameter> typeParameters = target.function.typeParameters;
     if (target is Constructor) {
       assert(!target.enclosingClass.isAbstract);
       typeParameters = target.enclosingClass.typeParameters;
     }
     if (!checkArguments(target.function, arguments, typeParameters)) {
       return throwNoSuchMethodError(new NullLiteral()..fileOffset = charOffset,
           target.name.name, arguments, charOffset);
     }
     if (target is Constructor) {
+      if (isConst && !target.isConst) {
+        return buildCompileTimeError("Not a const constructor.", charOffset);
+      }
       return new KernelConstructorInvocation(target, initialTarget, arguments,
           isConst: isConst)
         ..fileOffset = charOffset;
     } else if (target is Procedure && target.kind == ProcedureKind.Factory) {
       return new KernelFactoryConstructorInvocation(
           target, initialTarget, arguments,
           isConst: isConst)
         ..fileOffset = charOffset;
     } else {
+      Procedure factory = target;

[Johnni Winther, 2017/06/12 07:46:16]

Shouldn't this be in the if branch above?

[ahe, 2017/06/12 08:13:22]

Yes, good catch!

This is a merge problem. Paul added KernelFactoryConstructorInvocation after I
originally wrote this code, and I didn't notice it when merging.

I'll fix this in a follow-up CL.

+      if (isConst && !factory.isConst) {
+        return buildCompileTimeError("Not a const factory.", charOffset);
+      }
       return new KernelStaticInvocation(target, arguments, isConst: isConst)
         ..fileOffset = charOffset;
     }
   }
 
   @override
   bool checkArguments(FunctionNode function, Arguments arguments,
       List<TypeParameter> typeParameters) {
     if (arguments.positional.length < function.requiredParameterCount ||
         arguments.positional.length > function.positionalParameters.length) {
@@ skipping 331 matching lines @@
     JumpTarget breakTarget = exitBreakTarget();
     if (continueTarget.hasUsers) {
       body = new LabeledStatement(body);
       continueTarget.resolveContinues(body);
     }
     VariableDeclaration variable;
     bool declaresVariable = false;
     if (lvalue is VariableDeclaration) {
       declaresVariable = true;
       variable = lvalue;
+      if (variable.isConst) {
+        addCompileTimeError(
+            variable.fileOffset, "A for-in loop-variable can't be 'const'.");
+      }
     } else if (lvalue is FastaAccessor) {
       /// We are in this case, where `lvalue` isn't a [VariableDeclaration]:
       ///
       ///     for (lvalue in expression) body
       ///
       /// This is normalized to:
       ///
       ///     for (final #t in expression) {
       ///       lvalue = #t;
       ///       body;
@@ skipping 527 matching lines @@
           buildCompileTimeError(
               "'$name' isn't an instance field of this class.", offset),
           offset);
     }
   }
 
   @override
   Initializer buildSuperInitializer(
       Constructor constructor, Arguments arguments,
       [int charOffset = -1]) {
+    if (member.isConst && !constructor.isConst) {
+      return buildInvalidInitializer(
+          buildCompileTimeError("Super constructor isn't const.", charOffset),
+          charOffset);
+    }
     needsImplicitSuperInitializer = false;
     return new SuperInitializer(constructor, arguments)
       ..fileOffset = charOffset;
   }
 
   @override
   Initializer buildRedirectingInitializer(
       Constructor constructor, Arguments arguments,
       [int charOffset = -1]) {
     needsImplicitSuperInitializer = false;
@@ skipping 574 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }