update analyzer to 0.24.4 and remove an old workaround

lib/src/checker/resolver.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.
 
 /// Encapsulates how to invoke the analyzer resolver and overrides how it
 /// computes types on expressions to use our restricted set of types.
 library dev_compiler.src.checker.resolver;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 433 matching lines @@
   /// internally skipped. These initializers are fully resolved and don't need
   /// to be re-resolved on a sunsequent pass.
   final _visitedInitializers = new Set<VariableDeclaration>();
 
   RestrictedResolverVisitor(Library library, Source source,
       TypeProvider typeProvider, ResolverOptions options)
       : _typeProvider = typeProvider,
         super.con1(library, source, typeProvider,
             typeAnalyzerFactory: RestrictedStaticTypeAnalyzer.constructor);
 
-  @override
-  visitCatchClause(CatchClause node) {
-    var stack = node.stackTraceParameter;
-    if (stack != null) {
-      // TODO(jmesserly): analyzer does not correctly associate StackTrace type.
-      // It happens too late in TypeResolverVisitor visitCatchClause.
-      var element = stack.staticElement;
-      if (element is VariableElementImpl && element.type == null) {
-        // From the language spec:
-        // The static type of p1 is T and the static type of p2 is StackTrace.
-        element.type = _typeProvider.stackTraceType;
-      }
-    }
-    return super.visitCatchClause(node);
-  }
-
   reanalyzeInitializer(VariableDeclaration variable) {
     try {
       _revisiting = true;
       _nodeWasSkipped = false;
       var node = variable.parent.parent;
       var oldState;
       var state = _stateAtDeclaration[node];
       if (state != null) {
         oldState = new _ResolverState(this);
         state.restore(this);
@@ skipping 221 matching lines @@
         _typeProvider.doubleType,
         _typeProvider.boolType,
         _typeProvider.stringType
       ];
     }
     return _sealedTypes.contains(t);
   }
 
   @override // to propagate types to identifiers
   visitMethodInvocation(MethodInvocation node) {
-    // TODO(sigmund): follow up with analyzer team - why is this needed?
+    // TODO(jmesserly): we rely on having a staticType propagated to the
+    // methodName identifier. This shouldn't be necessary for method calls, so
+    // analyzer doesn't do it by default. Conceptually what we're doing here
+    // is asking for a tear off. We need this until we can fix #132, and rely
+    // on `node.staticElement == null` instead of `rules.isDynamicCall(node)`.
     visitSimpleIdentifier(node.methodName);
+
     super.visitMethodInvocation(node);
 
     // Search for Object methods.
     var objectMap = _getObjectMemberMap();
     var name = node.methodName.name;
     if (node.staticType.isDynamic &&
         objectMap.containsKey(name) &&
         isDynamicTarget(node.target)) {
       var type = objectMap[name];
       if (type is FunctionType && node.argumentList.arguments.isEmpty) {
@@ skipping 79 matching lines @@
     }
   }
 
   // Review note: no longer need to override visitFunctionExpression, this is
   // handled by the analyzer internally.
   // TODO(vsm): in visitbinaryExpression: check computeStaticReturnType result?
   // TODO(vsm): in visitFunctionDeclaration: Should we ever use the expression
   // type in a (...) => expr or just the written type?
 
 }