Insert implicit downcasts in kernel strong mode.

pkg/kernel/lib/analyzer/ast_from_analyzer.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 kernel.analyzer.ast_from_analyzer;
 
 import '../ast.dart' as ast;
 import '../frontend/accessors.dart';
 import '../frontend/super_initializers.dart';
 import '../log.dart';
 import '../type_algebra.dart';
@@ skipping 289 matching lines @@
   TypeScope(ReferenceLevelLoader loader) : super(loader) {
     _typeBuilder = new TypeAnnotationBuilder(this);
   }
 
   String get location => '?';
 
   bool get allowClassTypeParameters => false;
 
   ast.DartType get defaultTypeParameterBound => getRootClassReference().rawType;
 
+  ast.TypeParameter tryGetTypeParameterReference(TypeParameterElement element) {
+    return localTypeParameters[element] ??
+        loader.tryGetClassTypeParameter(element);
+  }
+
   ast.TypeParameter getTypeParameterReference(TypeParameterElement element) {
     return localTypeParameters[element] ??
         loader.tryGetClassTypeParameter(element) ??
         (localTypeParameters[element] = new ast.TypeParameter(element.name));
   }
 
   ast.TypeParameter makeTypeParameter(TypeParameterElement element,
       {ast.DartType bound}) {
     var typeParameter = getTypeParameterReference(element);
     assert(bound != null);
@@ skipping 58 matching lines @@
       // variables.  If successful, use the substituted types in the order
       // they occur in the type parameter list.
       var substitution = unifyTypes(genericFunctionType.withoutTypeParameters,
           inferredFunctionType, genericFunctionType.typeParameters.toSet());
       if (substitution != null) {
         return genericFunctionType.typeParameters
             .map((p) => substitution[p] ?? const ast.DynamicType())
             .toList();
       }
       return new List<ast.DartType>.filled(
-          genericFunctionType.typeParameters.length, const ast.DynamicType());
+          genericFunctionType.typeParameters.length, const ast.DynamicType(),
+          growable: true);
     } else {
       return <ast.DartType>[];
     }
   }
 
   List<ast.DartType> buildOptionalTypeArgumentList(TypeArgumentList node) {
     if (node == null) return null;
     return _typeBuilder.buildList(node.arguments);
   }
 
@@ skipping 778 matching lines @@
     loop = makeBreakTarget(loop, breakNode);
     if (initialExpression != null) {
       return new ast.Block(<ast.Statement>[
         new ast.ExpressionStatement(initialExpression),
         loop
       ]);
     }
     return loop;
   }
 
+  DartType iterableElementType(DartType iterable) {
+    if (iterable is InterfaceType) {
+      var iterator = iterable.lookUpInheritedGetter('iterator')?.returnType;
+      if (iterator is InterfaceType) {
+        return iterator.lookUpInheritedGetter('current')?.returnType;
+      }
+    }
+    return null;
+  }
+
+  DartType streamElementType(DartType stream) {
+    if (stream is InterfaceType) {
+      var class_ = stream.element;
+      if (class_.library.isDartAsync &&
+          class_.name == 'Stream' &&
+          stream.typeArguments.length == 1) {
+        return stream.typeArguments[0];
+      }
+    }
+    return null;
+  }
+
   ast.Statement visitForEachStatement(ForEachStatement node) {
     ast.VariableDeclaration variable;
     Accessor leftHand;
     if (node.loopVariable != null) {
       DeclaredIdentifier loopVariable = node.loopVariable;
       variable = scope.makeVariableDeclaration(loopVariable.element,
           type: scope.buildOptionalTypeAnnotation(loopVariable.type));
     } else if (node.identifier != null) {
       leftHand = scope.buildLeftHandValue(node.identifier);
-      // TODO: In strong mode, set variable type based on iterable type.
       variable = new ast.VariableDeclaration(null, isFinal: true);
+      if (scope.strongMode) {
+        var containerType = node.iterable.staticType;
+        DartType elementType = node.awaitKeyword != null
+            ? streamElementType(containerType)
+            : iterableElementType(containerType);
+        if (elementType != null) {
+          variable.type = scope.buildType(elementType);
+        }
+      }
     }
     var breakNode = new LabelStack.unlabeled(breakStack);
     var continueNode = new LabelStack.unlabeled(continueStack);
     addLoopLabels(node, continueNode);
     var body = buildInScope(node.body, breakNode, continueNode);
     if (leftHand != null) {
       // Desugar
       //
       //     for (x in e) BODY
       //
       // to
       //
       //     for (var tmp in e) {
       //       x = tmp;
       //       BODY
       //     }
       body = new ast.Block(<ast.Statement>[
         new ast.ExpressionStatement(leftHand
             .buildAssignment(new ast.VariableGet(variable), voidContext: true)),
         body
       ]);
     }
     var loop = new ast.ForInStatement(
         variable,
         scope.buildExpression(node.iterable),
         makeBreakTarget(body, continueNode),
-        isAsync: node.awaitKeyword != null);
+        isAsync: node.awaitKeyword != null)..fileOffset = node.offset;
     return makeBreakTarget(loop, breakNode);
   }
 
   ast.Statement visitIfStatement(IfStatement node) {
     return new ast.IfStatement(scope.buildExpression(node.condition),
         build(node.thenStatement), buildOptional(node.elseStatement));
   }
 
   ast.Statement visitReturnStatement(ReturnStatement node) {
     return new ast.ReturnStatement(
@@ skipping 50 matching lines @@
   ast.Statement visitYieldStatement(YieldStatement node) {
     return new ast.YieldStatement(scope.buildExpression(node.expression),
         isYieldStar: node.star != null);
   }
 
   ast.Statement visitFunctionDeclarationStatement(
       FunctionDeclarationStatement node) {
     var declaration = node.functionDeclaration;
     var expression = declaration.functionExpression;
     LocalElement element = declaration.element as dynamic; // Cross cast.
-    // TODO: Set a function type on the variable.
     return new ast.FunctionDeclaration(
-        scope.makeVariableDeclaration(element),
+        scope.makeVariableDeclaration(element,
+            type: scope.buildType(declaration.element.type)),
         scope.buildFunctionNode(expression.parameters, expression.body,
             typeParameters: scope.buildOptionalTypeParameterList(
                 expression.typeParameters,
                 strongModeOnly: true),
             returnType: declaration.returnType))..fileOffset = node.offset;
   }
 
   @override
   visitStatement(Statement node) {
     return scope.internalError('Unhandled statement ${node.runtimeType}');
@@ skipping 835 matching lines @@
   /// If [boundVariables] is null, no type variables are replaced, otherwise all
   /// type variables except those in [boundVariables] are replaced.  In other
   /// words, it represents the bound variables, or "all variables" if omitted.
   ast.DartType convertType(
       DartType type, List<TypeParameterElement> boundVariables) {
     if (type is TypeParameterType) {
       if (isUnreifiedTypeParameter(type.element)) {
         return const ast.DynamicType();
       }
       if (boundVariables == null || boundVariables.contains(type)) {
-        var typeParameter = scope.getTypeParameterReference(type.element);
+        var typeParameter = scope.tryGetTypeParameterReference(type.element);
+        if (typeParameter == null) {
+          // The analyzer sometimes gives us a type parameter that was not
+          // bound anywhere.  Make sure we do not emit a dangling reference.
+          if (type.element.bound != null) {
+            return convertType(type.element.bound, []);
+          }
+          return const ast.DynamicType();
+        }
         if (!scope.allowClassTypeParameters &&
             typeParameter.parent is ast.Class) {
           return const ast.InvalidType();
         }
         return new ast.TypeParameterType(typeParameter);
       } else {
         return const ast.DynamicType();
       }
     } else if (type is InterfaceType) {
       var classNode = scope.getClassReference(type.element);
@@ skipping 728 matching lines @@
     if (list[i - 1].compareTo(item) == 0) {
       ++deleted;
     } else if (deleted > 0) {
       list[i - deleted] = item;
     }
   }
   if (deleted > 0) {
     list.length -= deleted;
   }
 }