[cleanup] remove sloppy generator/async function maps

test/mjsunit/harmony/async-await-basic.js

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Flags: --harmony-async-await --allow-natives-syntax
 
 // Do not install `AsyncFunction` constructor on global object
 
 function assertThrowsAsync(run, errorType, message) {
   var actual;
@@ skipping 126 matching lines @@
                                     Symbol.toStringTag);
 assertEquals("AsyncFunction", descriptor.value);
 assertEquals(false, descriptor.enumerable);
 assertEquals(false, descriptor.writable);
 assertEquals(true, descriptor.configurable);
 
 assertEquals(1, AsyncFunction.length);
 
 // Let F be ! FunctionAllocate(functionPrototype, Strict, "non-constructor")
 async function asyncNonConstructorDecl() {}
-assertThrows(
-    () => new asyncNonConstructorDecl(), TypeError);
-assertThrows(
-    () => new (async function() {}), TypeError);
+assertThrows(() => new asyncNonConstructorDecl(), TypeError);
+assertThrows(() => asyncNonConstructorDecl.caller, TypeError);
+assertThrows(() => asyncNonConstructorDecl.arguments, TypeError);
+
+assertThrows(() => new (async function() {}), TypeError);
+assertThrows(() => (async function() {}).caller, TypeError);
+assertThrows(() => (async function() {}).arguments, TypeError);
+
 assertThrows(
     () => new ({ async nonConstructor() {} }).nonConstructor(), TypeError);
 assertThrows(
-    () => new (() => "not a constructor!"), TypeError);
+    () => ({ async nonConstructor() {} }).nonConstructor.caller, TypeError);
 assertThrows(
-    () => new (AsyncFunction()), TypeError);
-assertThrows(
-    () => new (new AsyncFunction()), TypeError);
+    () => ({ async nonConstructor() {} }).nonConstructor.arguments, TypeError);
+
+assertThrows(() => new (() => "not a constructor!"), TypeError);
+assertThrows(() => (() => 1).caller, TypeError);
+assertThrows(() => (() => 1).arguments, TypeError);
+
+assertThrows(() => new (AsyncFunction()), TypeError);
+assertThrows(() => AsyncFunction().caller, TypeError);
+assertThrows(() => AsyncFunction().arguments, TypeError);
+
+assertThrows(() => new (new AsyncFunction()), TypeError);
+assertThrows(() => (new AsyncFunction()).caller, TypeError);
+assertThrows(() => (new AsyncFunction()).arguments, TypeError);
 
 // Normal completion
 async function asyncDecl() { return "test"; }
 assertEqualsAsync("test", asyncDecl);
 assertEqualsAsync("test2", async function() { return "test2"; });
 assertEqualsAsync("test3", async () => "test3");
 assertEqualsAsync("test4", () => ({ async f() { return "test4"; } }).f());
 assertEqualsAsync("test5", () => AsyncFunction("no", "return 'test' + no;")(5));
 assertEqualsAsync("test6",
                   () => (new AsyncFunction("no", "return 'test' + no;"))(6));
@@ skipping 200 matching lines @@
     "20", () => (async(foo, { a = "0" }) => foo + a)("2", { a: undefined }));
 assertThrows(() => eval("async({ foo = 1 })"), SyntaxError);
 assertThrows(() => eval("async(a, { foo = 1 })"), SyntaxError);
 
 // https://bugs.chromium.org/p/chromium/issues/detail?id=638019
 async function gaga() {
   let i = 1;
   while (i-- > 0) { await 42 }
 }
 assertDoesNotThrow(gaga);