Resolve type Dynamic and implement black listing.

dart/frog/leg/resolver.dart

 // Copyright (c) 2012, 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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
 }
 
 class TreeElementMapping implements TreeElements {
@@ skipping 1245 matching lines @@
           variableElement.bound = boundType;
         } else {
           variableElement.bound = compiler.objectClass.computeType(compiler);
         }
       }
     }
     // Find super type.
     Type supertype = visit(node.superclass);
     if (supertype !== null && supertype.element.isExtendable()) {
       classElement.supertype = supertype;
+      if (isBlackListed(supertype)) {
+        error(node.superclass, MessageKind.CANNOT_EXTEND, [supertype]);
+      }
     } else if (supertype !== null) {
       error(node.superclass, MessageKind.TYPE_NAME_EXPECTED);
     }
     if (classElement.name != Types.OBJECT && classElement.supertype === null) {
       ClassElement objectElement = context.lookup(Types.OBJECT);
       if (objectElement !== null && !objectElement.isResolved) {
         compiler.resolver.toResolve.add(objectElement);
       } else if (objectElement === null){
         error(node, MessageKind.CANNOT_RESOLVE_TYPE, [Types.OBJECT]);
       }
       classElement.supertype = new SimpleType(Types.OBJECT, objectElement);
     }
     if (node.defaultClause !== null) {
       classElement.defaultClass = visit(node.defaultClause);
     }
     for (Link<Node> link = node.interfaces.nodes;
          !link.isEmpty();
          link = link.tail) {
       Type interfaceType = visit(link.head);
       if (interfaceType !== null && interfaceType.element.isExtendable()) {
         classElement.interfaces =
             classElement.interfaces.prepend(interfaceType);
+        if (isBlackListed(interfaceType)) {
+          error(link.head, MessageKind.CANNOT_IMPLEMENT, [interfaceType]);
+        }
       } else {
         error(link.head, MessageKind.TYPE_NAME_EXPECTED);
       }
     }
     calculateAllSupertypes(classElement, new Set<ClassElement>());
     addDefaultConstructorIfNeeded(classElement);
     return classElement.computeType(compiler);
   }
 
   Type visitTypeAnnotation(TypeAnnotation node) {
@@ skipping 109 matching lines @@
     element.constructors[element.name] = constructor;
     Type returnType = compiler.types.voidType;
     constructor.type = new FunctionType(returnType, const EmptyLink<Type>(),
                                         constructor);
     constructor.cachedNode =
       new FunctionExpression(new Identifier(element.position()),
                              new NodeList.empty(),
                              new Block(new NodeList.empty()),
                              null, null, null, null);
   }
+
+  isBlackListed(Type type) {
+    LibraryElement lib = classElement.getLibrary();
+    return
+      lib !== compiler.coreLibrary &&
+      lib !== compiler.coreImplLibrary &&
+      lib !== compiler.jsHelperLibrary &&
+      (type.element === compiler.dynamicClass ||
+       type.element === compiler.boolClass ||
+       type.element === compiler.numClass ||
+       type.element === compiler.intClass ||
+       type.element === compiler.doubleClass ||
+       type.element === compiler.stringClass ||
+       type.element === compiler.nullClass ||
+       type.element === compiler.functionClass);
+  }
 }
 
 class VariableDefinitionsVisitor extends CommonResolverVisitor<SourceString> {
   VariableDefinitions definitions;
   ResolverVisitor resolver;
   ElementKind kind;
   VariableListElement variables;
 
   VariableDefinitionsVisitor(Compiler compiler,
                              this.definitions, this.resolver, this.kind)
@@ skipping 323 matching lines @@
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }