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 363 matching lines @@
 
     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 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;

[vsm, 2015/02/25 20:52:28]

You could lift this block into the nested if above.  It's a no-op unless type is
not dynamic, right?

[Leaf, 2015/02/25 21:07:04]

Yeah, had it that way, then changed it just on the general principle that not
checking is kind of a latent bug if anybody later on adds non-trivial checks to
checkArgument when the type is dynamic.  I might be overthinking it though... 
:)    

+    for (int i = 0; i < elements.length; i++) {
+      elements[i] = checkArgument(elements[i], type);

[vsm, 2015/02/25 20:52:29]

Are you already keeping track of whether we're in a const setting?  If so, we
might want to think whether to generate a DownCast when we are.  It'll be
invalid Dart output - but ok in JS though.

[Leaf, 2015/02/25 21:07:04]

I'm not checking for const currently.  I considered rejecting downcasts in const
context here, but wanted to leave us open to generating them in the JS backend. 
Could do it, but controlled by a flag.  Hmmm...

+    }
+    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;

[vsm, 2015/02/25 20:52:29]

ditto

+    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 276 matching lines @@
   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);
   }
 }