Handle constructor declarations.

tests/compiler/dart2js/kernel/impact_test.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 dart2js.kernel.impact_test;
 
 import 'dart:async';
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/common.dart';
@@ skipping 55 matching lines @@
   testIsNotGenericDynamic(null);
   testIsTypedef(null);
   testIsTypedefGeneric(null);
   testIsTypedefGenericRaw(null);
   testIsTypedefGenericDynamic(null);
   testAs(null);
   testAsGeneric(null);
   testAsGenericRaw(null);
   testAsGenericDynamic(null);
   testThrow();
+  testIfNull(null);
+  testSetIfNull(null);
   testSyncStar();
   testAsync();
   testAsyncStar();
   testIfThen();
   testIfThenElse();
   testForIn(null);
   testForInTyped(null);
   testAsyncForIn(null);
   testAsyncForInTyped(null);
   testTryCatch();
@@ skipping 44 matching lines @@
   testFactoryInvokeGenericRaw();
   testFactoryInvokeGenericDynamic();
   testRedirectingFactoryInvoke();
   testRedirectingFactoryInvokeGeneric();
   testRedirectingFactoryInvokeGenericRaw();
   testRedirectingFactoryInvokeGenericDynamic();
   testConstRedirectingFactoryInvoke();
   testConstRedirectingFactoryInvokeGeneric();
   testConstRedirectingFactoryInvokeGenericRaw();
   testConstRedirectingFactoryInvokeGenericDynamic();
+  testImplicitConstructor();
+  testFactoryConstructor();
+  testDefaultValuesPositional();
+  testDefaultValuesNamed();
 }
 
 testEmpty() {}
 testNull() => null;
 testTrue() => true;
 testFalse() => false;
 testInt() => 42;
 testDouble() => 37.5;
 testString() => 'foo';
 testStringInterpolation() => '${0}';
@@ skipping 30 matching lines @@
 testIsNotGenericDynamic(o) => o is! GenericClass<dynamic, dynamic>;
 testIsTypedef(o) => o is Typedef;
 testIsTypedefGeneric(o) => o is GenericTypedef<int, String>;
 testIsTypedefGenericRaw(o) => o is GenericTypedef;
 testIsTypedefGenericDynamic(o) => o is GenericTypedef<dynamic, dynamic>;
 testAs(o) => o as Class;
 testAsGeneric(o) => o as GenericClass<int, String>;
 testAsGenericRaw(o) => o as GenericClass;
 testAsGenericDynamic(o) => o as GenericClass<dynamic, dynamic>;
 testThrow() => throw '';
+testIfNull(o) => o ?? 42;
+testSetIfNull(o) => o ??= 42;
 
 testSyncStar() sync* {}
 testAsync() async {}
 testAsyncStar() async* {}
 testIfThen() {
   if (false) return 42;
   return 1;
 }
 testIfThenElse() {
   if (true) {
@@ skipping 210 matching lines @@
 }
 testConstRedirectingFactoryInvokeGeneric() {
   const GenericClass<int, String>.redirect();
 }
 testConstRedirectingFactoryInvokeGenericRaw() {
   const GenericClass.redirect();
 }
 testConstRedirectingFactoryInvokeGenericDynamic() {
   const GenericClass<dynamic, dynamic>.redirect();
 }
+class ClassImplicitConstructor {}
+testImplicitConstructor() => new ClassImplicitConstructor();
+class ClassFactoryConstructor {
+  factory ClassFactoryConstructor() => null;
+}
+testFactoryConstructor() => new ClassFactoryConstructor();
+testDefaultValuesPositional([bool value = false]) {}
+testDefaultValuesNamed({bool value: false}) {}
 ''',
   'helper.dart': '''
 class Class {
   const Class.generative();
   factory Class.fact() => null;
   const factory Class.redirect() = Class.generative;
 }
 class GenericClass<X, Y> {
   const GenericClass.generative();
   factory GenericClass.fact() => null;
@@ skipping 18 matching lines @@
         ]);
     compiler.resolution.retainCachesForTesting = true;
     await compiler.run(entryPoint);
     checkLibrary(compiler, compiler.mainApp);
   });
 }
 
 void checkLibrary(Compiler compiler, LibraryElement library) {
   library.forEachLocalMember((AstElement element) {
     if (element.isClass) {
-      // TODO(johnniwinther): Handle class members.
+      ClassElement cls = element;
+      cls.forEachLocalMember((AstElement member) {
+        checkElement(compiler, member);
+      });
     } else if (element.isTypedef) {
       // Skip typedefs.
     } else {
       checkElement(compiler, element);
     }
   });
 }
 
 void checkElement(Compiler compiler, AstElement element) {
   ResolutionImpact astImpact = compiler.resolution.getResolutionImpact(element);
@@ skipping 10 matching lines @@
     Compiler compiler, AstElement element, ResolutionImpact impact) {
   ResolutionWorldImpactBuilder builder =
       new ResolutionWorldImpactBuilder('Lax impact of ${element}');
   for (StaticUse staticUse in impact.staticUses) {
     switch (staticUse.kind) {
       case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
         ConstructorElement constructor = staticUse.element;
         ConstructorElement effectiveTarget = constructor.effectiveTarget;
         DartType effectiveTargetType =
             constructor.computeEffectiveTargetType(staticUse.type);
-        builder.registerStaticUse(
-            new StaticUse.typedConstructorInvoke(effectiveTarget, null, effectiveTargetType));
+        builder.registerStaticUse(new StaticUse.typedConstructorInvoke(
+            effectiveTarget, null, effectiveTargetType));
         break;
       default:
         builder.registerStaticUse(staticUse);
         break;
     }
   }
   impact.dynamicUses.forEach(builder.registerDynamicUse);
   for (TypeUse typeUse in impact.typeUses) {
     if (typeUse.type.isTypedef) {
       typeUse = new TypeUse.internal(typeUse.type.unaliased, typeUse.kind);
@@ skipping 24 matching lines @@
         builder.registerFeature(Feature.THROW_EXPRESSION);
         break;
       default:
         builder.registerFeature(feature);
         break;
     }
   }
   impact.nativeData.forEach(builder.registerNativeData);
   return builder;
 }