Add flutter mode to patched_sdk

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 '../fasta_codes.dart'
     show
         FastaMessage,
         codeConstFieldWithoutInitializer,
@@ skipping 74 matching lines @@
   final ClassHierarchy hierarchy;
 
   final CoreTypes coreTypes;
 
   final bool isInstanceMember;
 
   final Scope enclosingScope;
 
   final bool enableNative;
 
-  final bool isBuiltinLibrary;
+  /// Whether to ignore an unresolved reference to `main` within the body of
+  /// `_getMainClosure` when compiling the current library.
+  ///
+  /// This as a temporary workaround. The standalone VM and flutter have
+  /// special logic to resolve `main` in `_getMainClosure`, this flag is used to
+  /// ignore that reference to `main`, but only on libraries where we expect to
+  /// see it (today that is dart:_builtin and dart:ui).
+  ///
+  // TODO(ahe,sigmund): remove when the VM gets rid of the special rule, see
+  // https://github.com/dart-lang/sdk/issues/28989.
+  final bool ignoreMainInGetMainClosure;
 
   @override
   final Uri uri;
 
   final TypeInferrer _typeInferrer;
 
   @override
   final TypePromoter typePromoter;
 
   /// Only used when [member] is a constructor. It tracks if an implicit super
@@ skipping 56 matching lines @@
       this.formalParameterScope,
       this.hierarchy,
       this.coreTypes,
       this.classBuilder,
       this.isInstanceMember,
       this.uri,
       this._typeInferrer)
       : enclosingScope = scope,
         library = library,
         enableNative = library.loader.target.enableNative(library),
-        isBuiltinLibrary =
-            library.uri.scheme == 'dart' && library.uri.path == "_builtin",
+        ignoreMainInGetMainClosure = library.uri.scheme == 'dart' &&
+            (library.uri.path == "_builtin" || library.uri.path == "ui"),
         needsImplicitSuperInitializer =
             coreTypes.objectClass != classBuilder?.cls,
         typePromoter = _typeInferrer.typePromoter,
         super(scope);
 
   bool get hasParserError => recoverableErrors.isNotEmpty;
 
   bool get inConstructor {
     return functionNestingLevel == 0 && member is KernelConstructorBuilder;
   }
@@ skipping 890 matching lines @@
         // a program that uses deferred loading. Obviously, this is a temporary
         // solution until we can fully implement deferred loading.
         addCompileTimeError(offset, message, wasHandled: false, silent: true);
         return buildCompileTimeError(message, offset);
       } else if (!isQualified && isInstanceContext) {
         assert(builder == null);
         if (constantExpressionRequired || member.isField) {
           return new UnresolvedAccessor(this, n, token);
         }
         return new ThisPropertyAccessor(this, token, n, null, null);
-      } else if (isBuiltinLibrary &&
+      } else if (ignoreMainInGetMainClosure &&
           name == "main" &&
           member?.name == "_getMainClosure") {
-        // TODO(ahe): https://github.com/dart-lang/sdk/issues/28989
         return new KernelNullLiteral()..fileOffset = offsetForToken(token);
       } else {
         return new UnresolvedAccessor(this, n, token);
       }
     } else if (builder.isTypeDeclaration) {
       if (constantExpressionRequired &&
           builder.isTypeVariable &&
           !member.isConstructor) {
         addCompileTimeError(
             offsetForToken(token), "Not a constant expression.");
@@ skipping 2560 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }