Rewire DDC to use the analyzer task model

lib/src/checker/rules.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 dev_compiler.src.checker.rules;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
@@ skipping 181 matching lines @@
       : _nonnullableTypes = <DartType>[],
         super(provider) {
     var types = options.nonnullableTypes;
     _nonnullableTypes.addAll(types.map(_typeFromName));
     inferrer = new DownwardsInference(this);
   }
 
   DartType getStaticType(Expression expr) {
     var type = expr.staticType;
     if (type != null) return type;
+    if (expr is SimpleIdentifier) {

[vsm, 2015/09/18 23:32:12]

Brian / Leaf - any suggestions on the right code here?  Without this, we're
hitting the missing type call before.  It looks like cases where the staticType
hasn't been registered with the AstNode but is on the element.

This fixes a number of "failures".

[Jennifer Messerly, 2015/09/19 00:18:46]

FYI, at least one place this used to happen was the "methodName" field of calls.
It happens because Analyzer doesn't need to compute the function type there, so
they don't (unless it's a tear off). However DDC has always relied on being able
to treat method calls as "tear off" + function call.

[Jennifer Messerly, 2015/09/19 00:23:38]

To clarify that:

Given `obj.method(args)`

analyzer would only care about the .staticType result for the whole
MethodInvocation, as well as `obj` and each of `args`. It would also compute the
Element for the method invocation.

DDC, however, would ask for the staticType of `.method` SimpleIdentifier too.
And expect it to be a function type with the signature (argTypes -> resultType).

See this line:
https://github.com/dart-lang/dev_compiler/blob/94d823b08e1a6420823bc7bc894fa4...

[Leaf, 2015/09/21 17:15:59]

I didn't port that line over because I was a little worried about how it would
interact, but I'll look into it.  Should be fine, I don't know any reason not to
have the type there.

[Brian Wilkerson, 2015/09/24 19:41:01]

Seems to me that we should change analyzer to always compute a function type
there. It would be good for ddc and possibly for other clients as well.

[Leaf, 2015/09/24 19:48:21]

I think the change on line 633 of this CL
https://codereview.chromium.org/1352763004/diff/80001/pkg/analyzer/lib/src/ge...
made this change unnecessary for DDC.  I had restricted the logic to strong mode
only, but could make it unconditional.

[Brian Wilkerson, 2015/09/24 21:17:48]

Yes. I think I made a comment to that effect in the review of that CL. :-)

I don't mind having different values for the static type information in strong
mode, but I'd prefer not to have the presence or absence of information depend
on the mode.

+      type = expr.staticElement?.type;
+      if (type != null) return type;
+    }
     if (reportMissingType != null) reportMissingType(expr);
     return provider.dynamicType;
   }
 
   bool _isBottom(DartType t, {bool dynamicIsBottom: false}) {
     if (t.isDynamic && dynamicIsBottom) return true;
     // TODO(vsm): We need direct support for non-nullability in DartType.
     // This should check on "true/nonnullable" Bottom
     if (t.isBottom && _nonnullableTypes.isEmpty) return true;
     return false;
@@ skipping 626 matching lines @@
     var entries = e.entries;
     bool inferEntry(MapLiteralEntry entry) {
       return _inferExpression(entry.key, kType, errors) &&
           _inferExpression(entry.value, vType, errors);
     }
     var b = entries.every(inferEntry);
     if (b) annotateMapLiteral(e, targs);
     return b;
   }
 }