anchor.diff:    }
   
     @override
  -  void beginExpression(Token token) {
  -    debugEvent("beginExpression");
  -    isFirstIdentifier = true;
  -  }
  -
  -  @override
     void handleIdentifier(Token token, IdentifierContext context) {
       debugEvent("handleIdentifier");
       String name = token.lexeme;
  -    if (isFirstIdentifier) {
  +    if (context.isScopeReference) {
         assert(!inInitializer ||
             this.scope == enclosingScope ||
             this.scope.parent == enclosingScope);
  
positive.code:   final Uri uri;
  
    Scope formalParameterScope;
  
    bool isFirstIdentifier = false;
  
    bool inInitializer = false;
  
  
negative.code:     push(new SymbolLiteral(value));
    }
  
    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);
      } 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();
  