Improve handling of complicated getters and setters.

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

 // Copyright (c) 2016, 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.
 
 library fasta.body_builder;
 
 import '../parser/parser.dart' show FormalParameterType, optional;
 
 import '../parser/error_kind.dart' show ErrorKind;
 
@@ skipping 179 matching lines @@
         return new TypeLiteral(type);
       }
     } else if (node is TypeDeclarationBuilder) {
       return new TypeLiteral(node.buildTypesWithBuiltArguments(library, null));
     } else if (node is KernelTypeBuilder) {
       return new TypeLiteral(node.build(library));
     } else if (node is Expression) {
       return node;
     } else if (node is PrefixBuilder) {
       return buildCompileTimeError("A library can't be used as an expression.");
+    } else if (node is ProblemBuilder) {
+      return buildProblemExpression(node, -1);
     } else {
       return internalError("Unhandled: ${node.runtimeType}");
     }
   }
 
   Expression toEffect(Object node) {
     if (node is BuilderAccessor) return node.buildForEffect();
     return toValue(node);
   }
 
@@ skipping 501 matching lines @@
     }
     return null;
   }
 
   @override
   void beginExpression(Token token) {
     debugEvent("beginExpression");
     isFirstIdentifier = true;
   }
 
-  Builder computeSetter(
-      Builder builder, Scope scope, String name, int charOffset) {
-    if (builder.isSetter) return builder;
-    if (builder.isGetter) return scope.lookupSetter(name, charOffset, uri);
-    return builder.isField ? (builder.isFinal ? null : builder) : null;
-  }
-
   @override
   void handleIdentifier(Token token, IdentifierContext context) {
     debugEvent("handleIdentifier");
     String name = token.lexeme;
     if (isFirstIdentifier) {
       assert(!inInitializer ||
           this.scope == enclosingScope ||
           this.scope.parent == enclosingScope);
       // This deals with this kind of initializer: `C(a) : a = a;`
       Scope scope = inInitializer ? enclosingScope : this.scope;
@@ skipping 24 matching lines @@
           this, charOffset, new Name(name, library.library), null, null);
     } else if (builder.isRegularMethod) {
       assert(builder.isStatic || builder.isTopLevel);
       return new StaticAccessor(this, charOffset, builder.target, null);
     } else if (builder is PrefixBuilder) {
       return builder;
     } else if (builder is MixedAccessor) {
       return new StaticAccessor(
           this, charOffset, builder.getter.target, builder.setter.target);
     } else {
-      if (builder is AccessErrorBuilder) {
-        AccessErrorBuilder error = builder;
-        builder = error.builder;
+      if (builder.hasProblem && builder is! AccessErrorBuilder) return builder;
+      Builder setter;
+      if (builder.isSetter) {
+        setter = builder;
+      } else if (builder.isGetter) {
+        setter = scope.lookupSetter(name, charOffset, uri);
+      } else if (builder.isField && !builder.isFinal) {
+        setter = builder;
       }
-      if (builder.target == null) {
-        return internalError("Unhandled: ${builder}");
-      }
-      Member getter = builder.target.hasGetter ? builder.target : null;
-      Member setter = builder.target.hasSetter ? builder.target : null;
-      setter ??= computeSetter(builder, scope, name, charOffset)?.target;
-      return new StaticAccessor(this, charOffset, getter, setter);
+      return new StaticAccessor.fromBuilder(this, builder, charOffset, setter);
     }
   }
 
   @override
   void handleQualified(Token period) {
     debugEvent("Qualified");
     Identifier name = pop();
     var receiver = pop();
     push([receiver, name]);
   }
@@ skipping 1949 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is BuilderAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }