Warnings for instantiating an abstract type.

frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 1074 matching lines @@
 }
 ImmutableMap.prototype.getValues = function() {
   return this._internal.getValues();
 }
 ImmutableMap.prototype.containsKey = function(key) {
   return this._internal.containsKey(key);
 }
 ImmutableMap.prototype.$setindex = function(key, value) {
   $throw(const$14/*const IllegalAccessException()*/);
 }
+ImmutableMap.prototype.putIfAbsent = function(key, ifAbsent) {
+  $throw(const$14/*const IllegalAccessException()*/);
+}
 ImmutableMap.prototype.forEach$1 = ImmutableMap.prototype.forEach;
 ImmutableMap.prototype.getKeys$0 = function() {
   return this.getKeys();
 };
 ImmutableMap.prototype.isEmpty$0 = function() {
   return this.isEmpty();
 };
 // ********** Code for NumImplementation **************
 NumImplementation = Number;
 NumImplementation.prototype.is$NumImplementation = function(){return this;};
@@ skipping 179 matching lines @@
     this._numberOfEntries++;
   }
   this._keys.$setindex(index, key);
   this._values.$setindex(index, value);
 }
 HashMapImplementation.prototype.$index = function(key) {
   var index = this._probeForLookup(key);
   if (index < 0) return null;
   return this._values.$index(index);
 }
+HashMapImplementation.prototype.putIfAbsent = function(key, ifAbsent) {
+  var index = this._probeForLookup(key);
+  if (index >= 0) return this._values.$index(index);
+  var value = ifAbsent();
+  this.$setindex(key, value);
+  return value;
+}
 HashMapImplementation.prototype.remove = function(key) {
   var index = this._probeForLookup(key);
   if (index >= 0) {
     this._numberOfEntries--;
     var value = this._values.$index(index);
     this._values.$setindex(index);
     this._keys.$setindex(index, const$1/*HashMapImplementation._DELETED_KEY*/);
     this._numberOfDeleted++;
     return value;
   }
@@ skipping 418 matching lines @@
     this._list.addLast(new KeyValuePair$K$V(key, value));
     this._map.$setindex(key, this._list.lastEntry());
   }
 }
 LinkedHashMapImplementation.prototype.$index = function(key) {
   var $0;
   var entry = (($0 = this._map.$index(key)) && $0.is$DoubleLinkedQueueEntry$KeyValuePair$K$V());
   if (entry == null) return null;
   return entry.get$element().get$value();
 }
+LinkedHashMapImplementation.prototype.putIfAbsent = function(key, ifAbsent) {
+  var value = this.$index(key);
+  if ((this.$index(key) == null) && !(this.containsKey(key))) {
+    value = ifAbsent();
+    this.$setindex(key, value);
+  }
+  return value;
+}
 LinkedHashMapImplementation.prototype.getKeys = function() {
   var list = new ListFactory(this.get$length());
   var index = 0;
   this._list.forEach(function _(entry) {
     list.$setindex(index++, entry.key);
   }
   );
   $assert(index == this.get$length(), "index == length", "linked_hash_map.dart", 75, 12);
   return list;
 }
@@ skipping 12448 matching lines @@
         code = ('' + target.get$dynamic().get$values().isEmpty$0());
       }
     }
   }
   if (this.name == 'get\$typeName' && $eq(this.declaringType.get$library(), $globals.world.get$dom())) {
     $globals.world.gen.corejs.useTypeNameOf = true;
   }
   return new Value(this.get$inferredResult(), code, node.span, true);
 }
 MethodMember.prototype._invokeConstructor = function(context, node, target, args, argsString) {
+  var $0;
   this.declaringType.markUsed();
   if (!$notnull_bool(target.isType)) {
     var code = (this.get$constructorName() != '') ? ('' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$ctor.call(' + argsString + ')') : ('' + this.declaringType.get$jsname() + '.call(' + argsString + ')');
     return new Value(target.type, code, node.span, true);
   }
   else {
+    if ($notnull_bool(this.declaringType.get$isAbstract())) {
+      $globals.world.warning(('Cannot instantiate abstract class ' + this.declaringType.name), node.span);
+      var members = groupBy((($0 = this.declaringType.get$inheritedMembers().getValues().filter$1((function (m) {
+        return m.get$isAbstract();
+      })
+      )) && $0.is$Iterable()), (function (m) {
+        return m.get$declaringType();
+      })
+      );
+      var msg = new StringBufferImpl(('Type ' + this.declaringType.name + ' is abstract ') + 'because it does not implement the following members');
+      var types = members.getKeys$0();
+      types.sort$1((function (x, y) {
+        return x.get$name().compareTo$1(y.get$name());
+      })
+      );
+      for (var $i = types.iterator$0(); $i.hasNext$0(); ) {
+        var type = $i.next$0();
+        if ($notnull_bool($ne(type, types.$index(0)))) msg.add$1(';');
+        msg.add$1((' from type ' + type.get$name() + ': '));
+        msg.add$1(Strings.join(map((($0 = members.$index(type)) && $0.is$Iterable()), (function (m) {
+          return m.get$name();
+        })
+        ), ', '));
+      }
+      $globals.world.warning(msg.toString$0(), this.declaringType.get$span());
+    }
     var code = (this.get$constructorName() != '') ? ('new ' + this.declaringType.get$jsname() + '.' + this.get$constructorName() + '\$ctor(' + argsString + ')') : ('new ' + this.declaringType.get$jsname() + '(' + argsString + ')');
     if ($notnull_bool(this.isConst) && (node instanceof lang_NewExpression) && $notnull_bool(node.get$dynamic().get$isConst())) {
       return this._invokeConstConstructor(node, $assert_String(code), target, args);
     }
     else {
       return new Value(target.type, code, node.span, true);
     }
   }
 }
 MethodMember.prototype._invokeConstConstructor = function(node, code, target, args) {
@@ skipping 5232 matching lines @@
 }
 lang_Type.prototype.get$parent = function() {
   return null;
 }
 lang_Type.prototype.getAllMembers = function() {
   return $map([]);
 }
 lang_Type.prototype.hashCode = function() {
   return this.name.hashCode();
 }
+lang_Type.prototype.get$isAbstract = function() {
+  if (this._isAbstract == null) {
+    if ($notnull_bool(this.get$isClass())) {
+      this._isAbstract = $assert_bool(this.get$inheritedMembers().getValues().some$1((function (m) {
+        return m.get$isAbstract();
+      })
+      ));
+    }
+    else {
+      this._isAbstract = true;
+    }
+  }
+  return this._isAbstract;
+}
+lang_Type.prototype.get$inheritedMembers = function() {
+  var $0;
+  if (this._inheritedMembers == null) {
+    this._inheritedMembers = (($0 = this._getInheritedMembers($map([]))) && $0.is$Map$String$Member());
+  }
+  return this._inheritedMembers;
+}
+lang_Type.prototype._getInheritedMembers = function(flattened) {
+  if (this.get$interfaces() != null) {
+    var $list = this.get$interfaces();
+    for (var $i = 0;$i < $list.length; $i++) {
+      var i = $list.$index($i);
+      i._getInheritedMembers(flattened);
+    }
+  }
+  if (this.get$parent() != null) {
+    this.get$parent()._getInheritedMembers(flattened);
+  }
+  var $list = this.getAllMembers().getValues();
+  for (var $i = this.getAllMembers().getValues().iterator$0(); $i.hasNext$0(); ) {
+    var m = $i.next$0();
+    flattened.$setindex(m.get$name(), m);
+  }
+  return flattened;
+}
 lang_Type.prototype._checkOverride = function(member) {
   var parentMember = this._getMemberInParents(member.name);
   if ($notnull_bool($ne(parentMember, null))) {
     if (!$notnull_bool(member.get$isPrivate()) || $eq(member.get$library(), parentMember.get$library())) {
       member.override((parentMember && parentMember.is$Member()));
     }
   }
 }
 lang_Type.prototype._createNotEqualMember = function() {
   var $0;
@@ skipping 601 matching lines @@
 DefinedType.prototype.set$constructors = function(value) { return this.constructors = value; };
 DefinedType.prototype.get$members = function() { return this.members; };
 DefinedType.prototype.set$members = function(value) { return this.members = value; };
 DefinedType.prototype.get$factories = function() { return this.factories; };
 DefinedType.prototype.set$factories = function(value) { return this.factories = value; };
 DefinedType.prototype.get$isUsed = function() { return this.isUsed; };
 DefinedType.prototype.set$isUsed = function(value) { return this.isUsed = value; };
 DefinedType.prototype.get$isNativeType = function() { return this.isNativeType; };
 DefinedType.prototype.set$isNativeType = function(value) { return this.isNativeType = value; };
 DefinedType.prototype.setDefinition = function(def) {
-  $assert(this.definition == null, "definition == null", "type.dart", 703, 12);
+  $assert(this.definition == null, "definition == null", "type.dart", 747, 12);
   this.definition = def;
   if ((this.definition instanceof TypeDefinition) && this.definition.get$nativeType() != null) {
     this.isNativeType = true;
   }
   if (this.definition != null && this.definition.get$typeParameters() != null) {
     this._concreteTypes = $map([]);
     this.typeParameters = [];
     var $list = this.definition.get$typeParameters();
     for (var $i = 0;$i < $list.length; $i++) {
       var tp = $list.$index($i);
@@ skipping 89 matching lines @@
     var resolvedInterface = this.resolveType((type && type.is$TypeReference()), true);
     if ($notnull_bool(resolvedInterface.get$isClosed()) && !($notnull_bool(this.library.get$isCore()) || $notnull_bool(this.library.get$isCoreImpl()))) {
       $globals.world.error(('can not implement "' + resolvedInterface.get$name() + '": ') + 'only native implementation allowed', (($0 = type.get$span()) && $0.is$SourceSpan()));
     }
     resolvedInterface.addDirectSubtype$1(this);
     interfaces.add$1(resolvedInterface);
   }
   return (interfaces && interfaces.is$List$Type());
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
-  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 819, 12);
+  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 863, 12);
   this.directSubtypes.add(type);
 }
 DefinedType.prototype.get$subtypes = function() {
   var $0;
   if (this._subtypes == null) {
     this._subtypes = new HashSetImplementation();
     var $list = this.directSubtypes;
     for (var $i = this.directSubtypes.iterator(); $i.hasNext$0(); ) {
       var st = $i.next$0();
       this._subtypes.add(st);
@@ skipping 357 matching lines @@
   }
   else {
     $globals.world.internalError('unknown type reference', node.span);
   }
   return node.type;
 }
 DefinedType.prototype.resolveTypeParams = function(inType) {
   return this;
 }
 DefinedType.prototype.getOrMakeConcreteType = function(typeArgs) {
-  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1248, 12);
+  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1292, 12);
   var names = [this.name];
   var typeMap = $map([]);
   for (var i = 0;
    i < typeArgs.length; i++) {
     var paramName = this.typeParameters.$index(i).get$name();
     typeMap.$setindex(paramName, typeArgs.$index(i));
     names.add$1(typeArgs.$index(i).get$name());
   }
   var concreteName = Strings.join((names && names.is$List$String()), '\$');
   var ret = this._concreteTypes.$index(concreteName);
   if ($notnull_bool(ret == null)) {
     ret = new ConcreteType($assert_String(concreteName), this, typeMap, typeArgs);
     this._concreteTypes.$setindex(concreteName, ret);
   }
   return (ret && ret.is$lang_Type());
 }
 DefinedType.prototype.getCallStub = function(args) {
-  $assert(this.get$isFunction(), "isFunction", "type.dart", 1268, 12);
+  $assert(this.get$isFunction(), "isFunction", "type.dart", 1312, 12);
   var name = _getCallStubName('call', args);
   if (this.varStubs == null) this.varStubs = $map([]);
   var stub = this.varStubs.$index(name);
   if ($notnull_bool(stub == null)) {
     stub = new VarFunctionStub($assert_String(name), args);
     this.varStubs.$setindex(name, stub);
   }
   return (stub && stub.is$VarFunctionStub());
 }
 DefinedType.prototype.addDirectSubtype$1 = function($0) {
@@ skipping 1333 matching lines @@
   code.exitBlock('});');
 }
 VarMethodSet.prototype.generate$1 = function($0) {
   return this.generate(($0 && $0.is$CodeWriter()));
 };
 VarMethodSet.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), ($3 && $3.is$Arguments()));
 };
 // ********** Code for top level **************
 function map(source, mapper) {
-  var result = new ListFactory();
+  var result = [];
   if (!!(source && source.is$List)) {
     var list = (source && source.is$List());
     result.length = list.length;
     for (var i = 0;
      i < list.length; i++) {
       result.$setindex(i, mapper(list.$index(i)));
     }
   }
   else {
     for (var $i = source.iterator(); $i.hasNext$0(); ) {
       var item = $i.next$0();
       result.add(mapper(item));
     }
   }
   return result;
 }
 function reduce(source, callback, initialValue) {
   var i = source.iterator();
   var current = initialValue;
   if ($notnull_bool(current == null) && $notnull_bool(i.hasNext$0())) {
     current = i.next$0();
   }
   while ($notnull_bool(i.hasNext$0())) {
     current = callback.call$2(current, i.next$0());
   }
   return current;
 }
+function groupBy(left, keyFn) {
+  var result = $map([]);
+  var iter = left.iterator();
+  while ($notnull_bool(iter.hasNext$0())) {
+    var i = iter.next$0();
+    result.putIfAbsent(keyFn(i), (function () {
+      return [];
+    })
+    ).add$1(i);
+  }
+  return result;
+}
 function orderValuesByKeys(map) {
   var $0;
   var keys = (($0 = map.getKeys()) && $0.is$List());
   keys.sort((function (x, y) {
     return x.compareTo$1(y);
   })
   );
   var values = [];
   for (var $i = 0;$i < keys.length; $i++) {
     var k = keys.$index($i);
@@ skipping 407 matching lines @@
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 var $globals = {};
 $static_init();
 main();