Dartc was not raising an error if an interface declared constructors without a default clause

tests/stub-generator/src/MintMakerFullyIsolatedTest.dart

 // Copyright (c) 2011, 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.
 
 // IsolateStubs=MintMakerFullyIsolatedTest.dart:Mint,Purse,PowerfulPurse
 #library("MintMakerFullyIsolatedTest-generatedTest");
 #import("../../isolate/src/TestFramework.dart");
 
-interface Purse {
+interface Purse default PurseImpl{
   Purse();
   int queryBalance();
   Purse$Proxy sproutPurse();
   // The deposit has not completed until the promise completes. If we
   // supported Promise<void> then this could use that.
   Promise<int> deposit(int amount, Purse$Proxy source);
 }
 
 interface PowerfulPurse extends Purse default PurseImpl {
   PowerfulPurse();
@@ skipping 94 matching lines @@
     s.addCompleteHandler((_) {
       print("PromiseMap.add move to map");
       _map[s] = t;
       _incomplete.remove(s);
     });
     return t;
   }
 
   Promise<T> find(S s) {
     print("PromiseMap.find");
-    Promise<T> result = new Promise<T>();
-    s.addCompleteHandler((_) {
+    Promise<T> findResult = new Promise<T>();
+    s.addCompleteHandler((unused) {
       print("PromiseMap.find s completed");
       T t = _map[s];
       if (t != null) {
         print("  immediate");
-        result.complete(t);
+        findResult.complete(t);
         return;
       }
       // Otherwise, we need to wait for map[s] to complete...
       int counter = _incomplete.length;
       if (counter == 0) {
         print("  none incomplete");
-        result.complete(null);
+        findResult.complete(null);
         return;
       }
-      result.join(_incomplete, bool (S completed) {
+      findResult.join(_incomplete, bool _(S completed) {
         if (completed != s) {
           if (--counter == 0) {
             print("PromiseMap.find failed");
-            result.complete(null);
+            findResult.complete(null);
             return true;
           }
           print("PromiseMap.find miss");
           return false;
         }
         print("PromiseMap.find complete");
-        result.complete(_map[s]);
+        findResult.complete(_map[s]);
         return true;
       });
     });
-    return result;
+    return findResult;
   }
 
   PromiseSet<S> _incomplete;
   Map<S, T> _map;
 
 }
 
 
 class MintImpl implements Mint {
 
@@ skipping 99 matching lines @@
     Promise<int> inner = new Promise<int>();
     Promise<int> inner2 = new Promise<int>();
     // FIXME(benl): it should not be necessary to wait here, I think,
     // but without this, the tests seem to execute prematurely.
     Promise<int> d1 = done.then((val) {
       expect.completesWithValue(sprouted.queryBalance(), 0 + 5);
       expect.completesWithValue(purse.queryBalance(), 100 - 5);
 
       done = sprouted.deposit(42, purse); 
       expect.completesWithValue(done, 5 + 42);
-      Promise<int> d2 = done.then((val) {
+      Promise<int> d2 = done.then((val_) {
         expect.completesWithValue(sprouted.queryBalance(), 0 + 5 + 42)
           .then((int value) => inner.complete(0));
         expect.completesWithValue(purse.queryBalance(), 100 - 5 - 42)
           .then((int value) => inner2.complete(0));
       });
       expect.completes(d2);
 
       return 0;
     });
     expect.completesWithValue(d1, 0);
     Promise<int> allDone = new Promise<int>();
     allDone.waitFor([d3, inner, inner2], 3);
     allDone.then((_) {
       expect.succeeded();
       print("##DONE##");
     });
   }
 
 }
 
 main() {
   runTests([MintMakerFullyIsolatedTest.testMain]);
 }