Typecheck map and list literals

lib/src/checker/checker.dart

 // Copyright (c) 2015, 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 ddc.src.checker.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/scanner.dart' show Token, TokenType;
@@ skipping 319 matching lines @@
     if (info.level >= logger.Level.SEVERE) _failure = true;
     _reporter.log(info);
   }
 }
 
 /// Checks the body of functions and properties.
 class CodeChecker extends RecursiveAstVisitor {
   final TypeRules _rules;
   final CheckerReporter _reporter;
   final _OverrideChecker _overrideChecker;
+  bool _constantContext = false;
   bool _failure = false;
   bool get failure => _failure || _overrideChecker._failure;
 
   CodeChecker(
       TypeRules rules, CheckerReporter reporter, CompilerOptions options)
       : _rules = rules,
         _reporter = reporter,
         _overrideChecker = new _OverrideChecker(rules, reporter, options);
 
+  _visitMaybeConst(AstNode n, visitNode(AstNode n)) {

[vsm, 2015/02/27 00:20:16]

Would be nice if we had generic methods.  :-)

[Leaf, 2015/02/27 00:44:21]

Acknowledged.

+    var o = _constantContext;
+    if (!o) {
+      if (n is VariableDeclarationList) {
+        _constantContext = o || n.isConst;
+      } else if (n is VariableDeclaration) {
+        _constantContext = o || n.isConst;
+      } else if (n is FormalParameter) {
+        _constantContext = o || n.isConst;
+      } else if (n is InstanceCreationExpression) {
+        _constantContext = o || n.isConst;
+      } else if (n is ConstructorDeclaration) {
+        _constantContext = o || n.element.isConst;
+      }
+    }
+    visitNode(n);
+    _constantContext = o;
+  }
+
   visitComment(Comment node) {
     // skip, no need to do typechecking inside comments (they may contain
     // comment references which would require resolution).
   }
 
   visitClassDeclaration(ClassDeclaration node) {
     _overrideChecker.check(node);
     super.visitClassDeclaration(node);
   }
 
   visitAssignmentExpression(AssignmentExpression node) {
     var token = node.operator;
     if (token.type != TokenType.EQ) {
       _checkCompoundAssignment(node);
     } else {
       DartType staticType = _rules.getStaticType(node.leftHandSide);
       node.rightHandSide = checkAssignment(node.rightHandSide, staticType);
     }
     node.visitChildren(this);
   }
 
-  /// Check constructor declaration to ensure correct super call placement.
-  @override
-  visitConstructorDeclaration(ConstructorDeclaration node) {
+  _visitConstructorDeclaration(ConstructorDeclaration node) {
     node.visitChildren(this);
 
     final init = node.initializers;
     for (int i = 0, last = init.length - 1; i < last; i++) {
       final node = init[i];
       if (node is SuperConstructorInvocation) {
         _recordMessage(new InvalidSuperInvocation(node));
       }
     }
   }
 
+  /// Check constructor declaration to ensure correct super call placement.
+  @override
+  visitConstructorDeclaration(ConstructorDeclaration node) {
+    _visitMaybeConst(node, _visitConstructorDeclaration);

[vsm, 2015/02/27 00:20:16]

Perhaps just inline the closure here instead of a separate function?  Similar
below?

[Leaf, 2015/02/27 00:44:21]

Done.

+  }
+
+  @override
+  visitInstanceCreationExpression(InstanceCreationExpression node) {
+    _visitMaybeConst(node, super.visitInstanceCreationExpression);
+  }
+
+  @override visitListLiteral(ListLiteral node) {
+    var type = _rules.provider.dynamicType;
+    if (node.typeArguments != null) {
+      var targs = node.typeArguments.arguments;
+      if (targs.length > 0) type = targs[0].type;
+    }
+    var elements = node.elements;
+    for (int i = 0; i < elements.length; i++) {
+      elements[i] = checkArgument(elements[i], type);
+    }
+    super.visitListLiteral(node);
+  }
+
+  @override visitMapLiteral(MapLiteral node) {
+    var ktype = _rules.provider.dynamicType;
+    var vtype = _rules.provider.dynamicType;
+    if (node.typeArguments != null) {
+      var targs = node.typeArguments.arguments;
+      if (targs.length > 0) ktype = targs[0].type;
+      if (targs.length > 1) vtype = targs[1].type;
+    }
+    var entries = node.entries;
+    for (int i = 0; i < entries.length; i++) {
+      var entry = entries[i];
+      entry.key = checkArgument(entry.key, ktype);
+      entry.value = checkArgument(entry.value, vtype);
+    }
+    super.visitMapLiteral(node);
+  }
+
   // Check invocations
   bool checkArgumentList(ArgumentList node, FunctionType type) {
     NodeList<Expression> list = node.arguments;
     int len = list.length;
     for (int i = 0; i < len; ++i) {
       Expression arg = list[i];
       ParameterElement element = node.getStaticParameterElementFor(arg);
       if (element == null) {
         if (type.parameters.length < len) {
           // We found an argument mismatch, the analyzer will report this too,
@@ skipping 107 matching lines @@
   visitPrefixedIdentifier(PrefixedIdentifier node) {
     final target = node.prefix;
     // Check if the prefix is a library - PrefixElement denotes a library
     // access.
     if (target.staticElement is! PrefixElement && _rules.isDynamicGet(target)) {
       _recordDynamicInvoke(node);
     }
     node.visitChildren(this);
   }
 
-  visitDefaultFormalParameter(DefaultFormalParameter node) {
+  _visitDefaultFormalParameter(DefaultFormalParameter node) {
     // Check that defaults have the proper subtype.
     var parameter = node.parameter;
     var parameterType = _rules.elementType(parameter.element);
     assert(parameterType != null);
     var defaultValue = node.defaultValue;
     var defaultType;
     if (defaultValue == null) {
       // TODO(vsm): Should this be null?
       defaultType = _rules.provider.bottomType;
     } else {
       defaultType = _rules.getStaticType(defaultValue);
     }
 
     // If defaultType is bottom, this enforces that parameterType is not
     // non-nullable.
     if (!_rules.isSubTypeOf(defaultType, parameterType)) {
       var staticInfo = (defaultValue == null)
           ? new InvalidVariableDeclaration(
               _rules, node.identifier, parameterType)
           : new StaticTypeError(_rules, defaultValue, parameterType);
       _recordMessage(staticInfo);
     }
     node.visitChildren(this);
   }
 
-  visitVariableDeclarationList(VariableDeclarationList node) {
+  @override visitDefaultFormalParameter(DefaultFormalParameter node) {
+    _visitMaybeConst(node, _visitDefaultFormalParameter);
+  }
+
+  _visitVariableDeclarationList(VariableDeclarationList node) {
     TypeName type = node.type;
     if (type == null) {
       // No checks are needed when the type is var. Although internally the
       // typing rules may have inferred a more precise type for the variable
       // based on the initializer.
     } else {
       var dartType = getType(type);
       for (VariableDeclaration variable in node.variables) {
         var initializer = variable.initializer;
         if (initializer != null) {
@@ skipping 10 matching lines @@
             var staticInfo =
                 new InvalidVariableDeclaration(_rules, variable, dartType);
             _recordMessage(staticInfo);
           }
         }
       }
     }
     node.visitChildren(this);
   }
 
+  @override
+  visitVariableDeclarationList(VariableDeclarationList node) {
+    _visitMaybeConst(node, _visitVariableDeclarationList);
+  }
+
+  @override
+  visitVariableDeclaration(VariableDeclaration node) {
+    _visitMaybeConst(node, super.visitVariableDeclaration);
+  }
+
   void _checkRuntimeTypeCheck(AstNode node, TypeName typeName) {
     var type = getType(typeName);
     if (!_rules.isGroundType(type)) {
       _recordMessage(new InvalidRuntimeCheckError(node, type));
     }
   }
 
   visitAsExpression(AsExpression node) {
     node.visitChildren(this);
   }
 
   visitIsExpression(IsExpression node) {
     _checkRuntimeTypeCheck(node, node.type);
     node.visitChildren(this);
   }
 
   DartType getType(TypeName name) {
     return (name == null) ? _rules.provider.dynamicType : name.type;
   }
 
   Expression checkAssignment(Expression expr, DartType type) {
-    final staticInfo = _rules.checkAssignment(expr, type);
+    final staticInfo = _rules.checkAssignment(expr, type, _constantContext);
     _recordMessage(staticInfo);
     if (staticInfo is Conversion) expr = staticInfo;
     return expr;
   }
 
   DartType _specializedBinaryReturnType(
       TokenType op, DartType t1, DartType t2, DartType normalReturnType) {
     // This special cases binary return types as per 16.26 and 16.27 of the
     // Dart language spec.
     switch (op) {
@@ skipping 53 matching lines @@
         } else {
           // Static type error
           staticInfo = new StaticTypeError(_rules, expr, lhsType);
         }
         _recordMessage(staticInfo);
       }
 
       // Check the rhs type
       if (staticInfo is! Conversion) {
         var paramType = paramTypes.first;
-        staticInfo = _rules.checkAssignment(expr.rightHandSide, paramType);
+        staticInfo = _rules.checkAssignment(
+            expr.rightHandSide, paramType, _constantContext);
         _recordMessage(staticInfo);
         if (staticInfo is Conversion) expr.rightHandSide = staticInfo;
       }
     }
   }
 
   void _recordDynamicInvoke(AstNode node) {
     _reporter.log(new DynamicInvoke(_rules, node));
   }
 
   void _recordMessage(StaticInfo info) {
     if (info == null) return;
     if (info.level >= logger.Level.SEVERE) _failure = true;
     _reporter.log(info);
   }
 }