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)) {
+    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) {
-    node.visitChildren(this);
+    _visitMaybeConst(node, (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));
+      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));
+        }
       }
-    }
+    });
   }
 
   @override
   visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     var field = node.fieldName;
     DartType staticType = _rules.elementType(field.staticElement);
     node.expression = checkAssignment(node.expression, staticType);
     node.visitChildren(this);
   }
 
+  @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) {
-    // 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);
-    }
+  @override visitDefaultFormalParameter(DefaultFormalParameter node) {
+    _visitMaybeConst(node, (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);
+      // 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);
+    });
   }
 
   visitFieldFormalParameter(FieldFormalParameter node) {
     var element = node.element;
     var typeName = node.type;
     if (typeName != null) {
       var type = _rules.elementType(element);
       var fieldElement =
           node.identifier.staticElement as FieldFormalParameterElement;
       var fieldType = _rules.elementType(fieldElement.field);
       if (!_rules.isSubTypeOf(type, fieldType)) {
         var staticInfo =
             new InvalidParameterDeclaration(_rules, node, fieldType);
         _recordMessage(staticInfo);
       }
     }
     node.visitChildren(this);
   }
 
   @override
   visitInstanceCreationExpression(InstanceCreationExpression node) {
-    var arguments = node.argumentList;
-    var element = node.staticElement;
-    if (element != null) {
-      var type = _rules.elementType(node.staticElement);
-      checkArgumentList(arguments, type);
-    } else {
-      _recordMessage(new MissingTypeError(node));
-    }
-    node.visitChildren(this);
+    _visitMaybeConst(node, (node) {
+      var arguments = node.argumentList;
+      var element = node.staticElement;
+      if (element != null) {
+        var type = _rules.elementType(node.staticElement);
+        checkArgumentList(arguments, type);
+      } else {
+        _recordMessage(new MissingTypeError(node));
+      }
+      node.visitChildren(this);
+    });
   }
 
   @override
   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) {
-          variable.initializer = checkAssignment(initializer, dartType);
-        } else if (_rules.maybeNonNullableType(dartType)) {
-          var element = variable.element;
-          if (element is FieldElement && !element.isStatic) {
-            // Initialized - possibly implicitly - during construction.
-            // Handle this via a runtime check during code generation.
+    _visitMaybeConst(node, (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) {
+            variable.initializer = checkAssignment(initializer, dartType);
+          } else if (_rules.maybeNonNullableType(dartType)) {
+            var element = variable.element;
+            if (element is FieldElement && !element.isStatic) {
+              // Initialized - possibly implicitly - during construction.
+              // Handle this via a runtime check during code generation.
 
-            // TODO(vsm): Detect statically whether this can fail and
-            // report a static error (must fail) or warning (can fail).
-          } else {
-            var staticInfo =
-                new InvalidVariableDeclaration(_rules, variable, dartType);
-            _recordMessage(staticInfo);
+              // TODO(vsm): Detect statically whether this can fail and
+              // report a static error (must fail) or warning (can fail).
+            } else {
+              var staticInfo =
+                  new InvalidVariableDeclaration(_rules, variable, dartType);
+              _recordMessage(staticInfo);
+            }
           }
         }
       }
-    }
-    node.visitChildren(this);
+      node.visitChildren(this);
+    });
+  }
+
+  @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);
   }
 }