anchor.diff:      push(new SymbolLiteral(value));
     }
   
  -  DartType toKernelType(String name, List<DartType> arguments, int charOffset) {
  +  DartType kernelTypeFromString(
  +      String name, List<DartType> arguments, int charOffset) {
       Builder builder = scope.lookup(name, charOffset, uri);
  +    if (builder == null) {
  +      warning("Type not found: '$name'.", charOffset);
  +      return const DynamicType();
  +    } else {
  +      return kernelTypeFromBuilder(builder, arguments, charOffset);
  +    }
  +  }
  +
  +  DartType kernelTypeFromBuilder(
  +      Builder builder, List<DartType> arguments, int charOffset) {
       if (builder is TypeDeclarationBuilder) {
         return builder.buildTypesWithBuiltArguments(library, arguments);
  -    }
  -    if (builder == null) {
  -      warning("Type not found: '$name'.", charOffset);
  -    } else {
  -      warning("Not a type: '$name'.", charOffset);
  +    } else if (builder.hasProblem) {
  +      ProblemBuilder problem = builder;
  +      addCompileTimeError(charOffset, problem.message);
  +    } else {
  +      warning("Not a type: '${builder.fullNameForErrors}'.", charOffset);
       }
       // TODO(ahe): Create an error somehow.
       return const DynamicType();
  
positive.code: 
    @override
    void push(Object node) {
      isFirstIdentifier = false;
      inInitializer = false;
      super.push(node);
    }
  
negative.code:       push(name.buildTypesWithBuiltArguments(library, arguments));
      } else if (name is TypeBuilder) {
        push(name.build(library));
      } else if (name is Builder) {
        push(kernelTypeFromBuilder(name, arguments, beginToken.charOffset));
      } else if (name is String) {
        push(kernelTypeFromString(name, arguments, beginToken.charOffset));
      } else {
        internalError("Unhandled: '${name.runtimeType}'.");
      }
      if (peek() is TypeParameterType) {
        TypeParameterType type = peek();
  