Support default constructors in analyzer2dart.

pkg/analyzer2dart/lib/src/tree_shaker.dart

 // Copyright (c) 2014, 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 analyzer2dart.treeShaker;
 
 import 'dart:collection';
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 72 matching lines @@
     MethodAnalysis analysis = new MethodAnalysis(declaration);
     if (declaration != null) {
       declaration.accept(new TreeShakingVisitor(analysis));
     } else if (method is ConstructorElement) {
       // This constructor has no associated declaration in the AST.  Either it
       // is a default constructor for an ordinary class, or it's a synthetic
       // constructor associated with a mixin.  For now we assume it's a default
       // constructor, in which case all we need to do is record the class as
       // being instantiated by this method.  TODO(paulberry): handle the
       // mixin case.
-      analysis.instantiates.add(method.enclosingElement);
+      ClassElement instantiatedClass = method.enclosingElement;
+      analysis.instantiates.add(instantiatedClass);
+      if (instantiatedClass.supertype != null) {
+        ClassElement superClass = instantiatedClass.supertype.element;
+        ConstructorElement superConstructor = superClass.unnamedConstructor;
+        if (superConstructor != null) {
+          // TODO(johnniwinther): Register instantiated type and selector.
+          analysis.calls.add(superConstructor);
+        }
+      }
     } else {
       // This is an executable element with no associated declaration in the
       // AST, and it's not a constructor.  TODO(paulberry): can this ever
       // happen?
       throw new UnimplementedError();
     }
     return analysis;
   }
 
   /**
@@ skipping 258 matching lines @@
     // TODO(paulberry): handle parameter list.
     node.initializers.accept(this);
     node.body.accept(this);
     if (node.factoryKeyword == null) {
       // This is a generative constructor.  Figure out if it is redirecting.
       // If it isn't, then the constructor instantiates the class so we need to
       // add the class to analysis.instantiates.  (If it is redirecting, then
       // we don't need to, because the redirected-to constructor will take care
       // of that).
       if (node.initializers.length != 1 || node.initializers[0] is! RedirectingConstructorInvocation) {
+        ClassElement classElement = node.element.enclosingElement;
         analysis.instantiates.add(node.element.enclosingElement);
+        if (!node.initializers.any((i) => i is SuperConstructorInvocation)) {
+          if (classElement.supertype != null) {
+            ClassElement superClass = classElement.supertype.element;
+            ConstructorElement superConstructor = superClass.unnamedConstructor;
+            if (superConstructor != null) {
+              // TODO(johnniwinther): Register instantiated type and selector.
+              analysis.calls.add(superConstructor);
+            }
+          }
+        }
       }
     } else if (node.redirectedConstructor != null) {
       if (node.redirectedConstructor.staticElement == null) {
         // Factory constructor redirects to a non-existent constructor.
         // TODO(paulberry): handle this.
         throw new UnimplementedError();
       } else {
         analysis.calls.add(node.redirectedConstructor.staticElement);
       }
     }
   }
 
   @override
   void
       visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     // Note: we don't have to worry about node.staticElement being
     // null, because that would have been detected by the analyzer and
     // reported as a compile time error.
     analysis.calls.add(node.staticElement);
   }
 
   @override
   void handleAssignmentExpression(AssignmentExpression node) {
     // Don't special-case assignment expressions.
   }
 }