maxmustermann/pulumi
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
pulumi/sdk/nodejs/runtime/closure/v8.ts

53 lines
2.6 KiB
TypeScript
Raw Normal View History

Add license headers
2018-05-22 21:43:36 +02:00
// Copyright 2016-2018, Pulumi Corporation.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
Implement scope chain free variable lookup in pure TypeScript (#1139) * Implement closure scope chain analysis in pure TypeScript This change makes use of four V8 intrinsics to avoid having to use a native module to inspect the scope chains of live Function objects. This unfortunately leads to the limitation of not allowing captures of 'this' in arrow functions, but that is something we are willing to live with for now. * Remove native module build and restore from the Makefile * CR feedback: Be a little more efficient when scanning the scope chain * Nuke everything related to custom Node versions and the native Node module * CR feedback: rename native.ts -> v8.ts, document some interfaces in v8.ts
2018-04-10 19:04:11 +02:00
Get closure serialiation working in Node11 (#2101) * Make v8 primitives async as there is no way to avoid async in node11. * Simplify API. * Move processing of well-known globals into the v8 layer. We'll need this so that we can map from RemoteObjectIds back to these well known values. * Remove unnecesssary check. * Cleanup comments and extract helper. * Introduce helper bridge method for the simple case of making an entry for a string. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Move property access behind helpers so they can move to the Inspector API in the future. * Only call function when we know we have a Function. Remove redundant null check. * Properly serialize certain special JavaScript number values that JSON serialization cannot handle. * Only marshall across the 'source' and 'flags' for a RegExp when serializing. * Add a simple test to validate a regex without flags. * Extract functionality into helper method. * Add test with complex output scenarios. * Output serialization needs to avoid recursively trying to serialize a serialized value. * Introduce indirection for introspecting properties of an object. * Use our own introspection API for examining an Array. * Hide direct property access through API indirection. * Produce values like the v8 Inspector does. * Compute the module map asynchronously. Will need that when mapping mirrors instead. * Cleanup a little code in closure creation. * Get serialization working on Node11 (except function locations). * Run tests in the same order on <v11 and >=v11 * Make tests run on multiple versions of node. * Rename file to make PR simpler to review. * Cleanup. * Be more careful with global state. * Remove commented line. * Only allow getting a session when on Node11 or above. * Promisify methods.
2018-11-01 23:46:21 +01:00
// This file provides a low-level interface to a few V8 runtime objects. We will use this low-level
// interface when serializing closures to walk the scope chain and find the value of free variables
// captured by closures, as well as getting source-level debug information so that we can present
// high-quality error messages.
Implement scope chain free variable lookup in pure TypeScript (#1139) * Implement closure scope chain analysis in pure TypeScript This change makes use of four V8 intrinsics to avoid having to use a native module to inspect the scope chains of live Function objects. This unfortunately leads to the limitation of not allowing captures of 'this' in arrow functions, but that is something we are willing to live with for now. * Remove native module build and restore from the Makefile * CR feedback: Be a little more efficient when scanning the scope chain * Nuke everything related to custom Node versions and the native Node module * CR feedback: rename native.ts -> v8.ts, document some interfaces in v8.ts
2018-04-10 19:04:11 +02:00
//
Get closure serialiation working in Node11 (#2101) * Make v8 primitives async as there is no way to avoid async in node11. * Simplify API. * Move processing of well-known globals into the v8 layer. We'll need this so that we can map from RemoteObjectIds back to these well known values. * Remove unnecesssary check. * Cleanup comments and extract helper. * Introduce helper bridge method for the simple case of making an entry for a string. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Move property access behind helpers so they can move to the Inspector API in the future. * Only call function when we know we have a Function. Remove redundant null check. * Properly serialize certain special JavaScript number values that JSON serialization cannot handle. * Only marshall across the 'source' and 'flags' for a RegExp when serializing. * Add a simple test to validate a regex without flags. * Extract functionality into helper method. * Add test with complex output scenarios. * Output serialization needs to avoid recursively trying to serialize a serialized value. * Introduce indirection for introspecting properties of an object. * Use our own introspection API for examining an Array. * Hide direct property access through API indirection. * Produce values like the v8 Inspector does. * Compute the module map asynchronously. Will need that when mapping mirrors instead. * Cleanup a little code in closure creation. * Get serialization working on Node11 (except function locations). * Run tests in the same order on <v11 and >=v11 * Make tests run on multiple versions of node. * Rename file to make PR simpler to review. * Cleanup. * Be more careful with global state. * Remove commented line. * Only allow getting a session when on Node11 or above. * Promisify methods.
2018-11-01 23:46:21 +01:00
// As a side-effect of importing this file, we must enable the --allow-natives-syntax V8 flag. This
// is because we are using V8 intrinsics in order to implement this module.
Implement scope chain free variable lookup in pure TypeScript (#1139) * Implement closure scope chain analysis in pure TypeScript This change makes use of four V8 intrinsics to avoid having to use a native module to inspect the scope chains of live Function objects. This unfortunately leads to the limitation of not allowing captures of 'this' in arrow functions, but that is something we are willing to live with for now. * Remove native module build and restore from the Makefile * CR feedback: Be a little more efficient when scanning the scope chain * Nuke everything related to custom Node versions and the native Node module * CR feedback: rename native.ts -> v8.ts, document some interfaces in v8.ts
2018-04-10 19:04:11 +02:00
import * as v8 from "v8";
v8.setFlagsFromString("--allow-natives-syntax");
Get closure serialiation working in Node11 (#2101) * Make v8 primitives async as there is no way to avoid async in node11. * Simplify API. * Move processing of well-known globals into the v8 layer. We'll need this so that we can map from RemoteObjectIds back to these well known values. * Remove unnecesssary check. * Cleanup comments and extract helper. * Introduce helper bridge method for the simple case of making an entry for a string. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Move property access behind helpers so they can move to the Inspector API in the future. * Only call function when we know we have a Function. Remove redundant null check. * Properly serialize certain special JavaScript number values that JSON serialization cannot handle. * Only marshall across the 'source' and 'flags' for a RegExp when serializing. * Add a simple test to validate a regex without flags. * Extract functionality into helper method. * Add test with complex output scenarios. * Output serialization needs to avoid recursively trying to serialize a serialized value. * Introduce indirection for introspecting properties of an object. * Use our own introspection API for examining an Array. * Hide direct property access through API indirection. * Produce values like the v8 Inspector does. * Compute the module map asynchronously. Will need that when mapping mirrors instead. * Cleanup a little code in closure creation. * Get serialization working on Node11 (except function locations). * Run tests in the same order on <v11 and >=v11 * Make tests run on multiple versions of node. * Rename file to make PR simpler to review. * Cleanup. * Be more careful with global state. * Remove commented line. * Only allow getting a session when on Node11 or above. * Promisify methods.
2018-11-01 23:46:21 +01:00
import * as v8Hooks from "./v8Hooks";
Do a better job preventing serialization of unnecessary objects in closure serialization (#1543)
2018-06-20 21:57:57 +02:00
Get closure serialiation working in Node11 (#2101) * Make v8 primitives async as there is no way to avoid async in node11. * Simplify API. * Move processing of well-known globals into the v8 layer. We'll need this so that we can map from RemoteObjectIds back to these well known values. * Remove unnecesssary check. * Cleanup comments and extract helper. * Introduce helper bridge method for the simple case of making an entry for a string. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Move property access behind helpers so they can move to the Inspector API in the future. * Only call function when we know we have a Function. Remove redundant null check. * Properly serialize certain special JavaScript number values that JSON serialization cannot handle. * Only marshall across the 'source' and 'flags' for a RegExp when serializing. * Add a simple test to validate a regex without flags. * Extract functionality into helper method. * Add test with complex output scenarios. * Output serialization needs to avoid recursively trying to serialize a serialized value. * Introduce indirection for introspecting properties of an object. * Use our own introspection API for examining an Array. * Hide direct property access through API indirection. * Produce values like the v8 Inspector does. * Compute the module map asynchronously. Will need that when mapping mirrors instead. * Cleanup a little code in closure creation. * Get serialization working on Node11 (except function locations). * Run tests in the same order on <v11 and >=v11 * Make tests run on multiple versions of node. * Rename file to make PR simpler to review. * Cleanup. * Be more careful with global state. * Remove commented line. * Only allow getting a session when on Node11 or above. * Promisify methods.
2018-11-01 23:46:21 +01:00
import * as v8_v10andLower from "./v8_v10andLower";
import * as v8_v11andHigher from "./v8_v11andHigher";
Fail closure serialization in Node 11 (#2098) * Fail closure serialization in Node 11 Node 11 changed many of the intrinsics that we depend upon for closure serialization, so until we fix the underlying issues this commit lazily fails if a closure is serialized when running on Node 11. * CR feedback
2018-10-25 19:55:47 +02:00
Get closure serialiation working in Node11 (#2101) * Make v8 primitives async as there is no way to avoid async in node11. * Simplify API. * Move processing of well-known globals into the v8 layer. We'll need this so that we can map from RemoteObjectIds back to these well known values. * Remove unnecesssary check. * Cleanup comments and extract helper. * Introduce helper bridge method for the simple case of making an entry for a string. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Move property access behind helpers so they can move to the Inspector API in the future. * Only call function when we know we have a Function. Remove redundant null check. * Properly serialize certain special JavaScript number values that JSON serialization cannot handle. * Only marshall across the 'source' and 'flags' for a RegExp when serializing. * Add a simple test to validate a regex without flags. * Extract functionality into helper method. * Add test with complex output scenarios. * Output serialization needs to avoid recursively trying to serialize a serialized value. * Introduce indirection for introspecting properties of an object. * Use our own introspection API for examining an Array. * Hide direct property access through API indirection. * Produce values like the v8 Inspector does. * Compute the module map asynchronously. Will need that when mapping mirrors instead. * Cleanup a little code in closure creation. * Get serialization working on Node11 (except function locations). * Run tests in the same order on <v11 and >=v11 * Make tests run on multiple versions of node. * Rename file to make PR simpler to review. * Cleanup. * Be more careful with global state. * Remove commented line. * Only allow getting a session when on Node11 or above. * Promisify methods.
2018-11-01 23:46:21 +01:00
// Node majorly changed their introspection apis between 10.0 and 11.0 (removing outright some
// of the APIs we use). Detect if we're before or after this change and delegate to the
const versionSpecificV8Module = v8Hooks.isNodeAtLeastV11 ? v8_v11andHigher : v8_v10andLower;
Implement scope chain free variable lookup in pure TypeScript (#1139) * Implement closure scope chain analysis in pure TypeScript This change makes use of four V8 intrinsics to avoid having to use a native module to inspect the scope chains of live Function objects. This unfortunately leads to the limitation of not allowing captures of 'this' in arrow functions, but that is something we are willing to live with for now. * Remove native module build and restore from the Makefile * CR feedback: Be a little more efficient when scanning the scope chain * Nuke everything related to custom Node versions and the native Node module * CR feedback: rename native.ts -> v8.ts, document some interfaces in v8.ts
2018-04-10 19:04:11 +02:00
/**
* Given a function and a free variable name, lookupCapturedVariableValue looks up the value of that free variable
* in the scope chain of the provided function. If the free variable is not found, `throwOnFailure` indicates
* whether or not this function should throw or return `undefined.
*
* @param func The function whose scope chain is to be analyzed
* @param freeVariable The name of the free variable to inspect
* @param throwOnFailure If true, throws if the free variable can't be found.
* @returns The value of the free variable. If `throwOnFailure` is false, returns `undefined` if not found.
Mark internal APIs `@internal` to filter from API docs (#3809) Also: - Cleaned up existing tags so they're consistently at the bottom of doc comments where they should be - Cleaned up some unused imports while I was taking a pass over the files - Marked one function `@deprecated` that should be deprecated
2020-01-26 18:06:35 +01:00
* @internal
Implement scope chain free variable lookup in pure TypeScript (#1139) * Implement closure scope chain analysis in pure TypeScript This change makes use of four V8 intrinsics to avoid having to use a native module to inspect the scope chains of live Function objects. This unfortunately leads to the limitation of not allowing captures of 'this' in arrow functions, but that is something we are willing to live with for now. * Remove native module build and restore from the Makefile * CR feedback: Be a little more efficient when scanning the scope chain * Nuke everything related to custom Node versions and the native Node module * CR feedback: rename native.ts -> v8.ts, document some interfaces in v8.ts
2018-04-10 19:04:11 +02:00
*/
Get closure serialiation working in Node11 (#2101) * Make v8 primitives async as there is no way to avoid async in node11. * Simplify API. * Move processing of well-known globals into the v8 layer. We'll need this so that we can map from RemoteObjectIds back to these well known values. * Remove unnecesssary check. * Cleanup comments and extract helper. * Introduce helper bridge method for the simple case of making an entry for a string. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Move property access behind helpers so they can move to the Inspector API in the future. * Only call function when we know we have a Function. Remove redundant null check. * Properly serialize certain special JavaScript number values that JSON serialization cannot handle. * Only marshall across the 'source' and 'flags' for a RegExp when serializing. * Add a simple test to validate a regex without flags. * Extract functionality into helper method. * Add test with complex output scenarios. * Output serialization needs to avoid recursively trying to serialize a serialized value. * Introduce indirection for introspecting properties of an object. * Use our own introspection API for examining an Array. * Hide direct property access through API indirection. * Produce values like the v8 Inspector does. * Compute the module map asynchronously. Will need that when mapping mirrors instead. * Cleanup a little code in closure creation. * Get serialization working on Node11 (except function locations). * Run tests in the same order on <v11 and >=v11 * Make tests run on multiple versions of node. * Rename file to make PR simpler to review. * Cleanup. * Be more careful with global state. * Remove commented line. * Only allow getting a session when on Node11 or above. * Promisify methods.
2018-11-01 23:46:21 +01:00
export const lookupCapturedVariableValueAsync = versionSpecificV8Module.lookupCapturedVariableValueAsync;
Implement scope chain free variable lookup in pure TypeScript (#1139) * Implement closure scope chain analysis in pure TypeScript This change makes use of four V8 intrinsics to avoid having to use a native module to inspect the scope chains of live Function objects. This unfortunately leads to the limitation of not allowing captures of 'this' in arrow functions, but that is something we are willing to live with for now. * Remove native module build and restore from the Makefile * CR feedback: Be a little more efficient when scanning the scope chain * Nuke everything related to custom Node versions and the native Node module * CR feedback: rename native.ts -> v8.ts, document some interfaces in v8.ts
2018-04-10 19:04:11 +02:00
/**
Get closure serialiation working in Node11 (#2101) * Make v8 primitives async as there is no way to avoid async in node11. * Simplify API. * Move processing of well-known globals into the v8 layer. We'll need this so that we can map from RemoteObjectIds back to these well known values. * Remove unnecesssary check. * Cleanup comments and extract helper. * Introduce helper bridge method for the simple case of making an entry for a string. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Move property access behind helpers so they can move to the Inspector API in the future. * Only call function when we know we have a Function. Remove redundant null check. * Properly serialize certain special JavaScript number values that JSON serialization cannot handle. * Only marshall across the 'source' and 'flags' for a RegExp when serializing. * Add a simple test to validate a regex without flags. * Extract functionality into helper method. * Add test with complex output scenarios. * Output serialization needs to avoid recursively trying to serialize a serialized value. * Introduce indirection for introspecting properties of an object. * Use our own introspection API for examining an Array. * Hide direct property access through API indirection. * Produce values like the v8 Inspector does. * Compute the module map asynchronously. Will need that when mapping mirrors instead. * Cleanup a little code in closure creation. * Get serialization working on Node11 (except function locations). * Run tests in the same order on <v11 and >=v11 * Make tests run on multiple versions of node. * Rename file to make PR simpler to review. * Cleanup. * Be more careful with global state. * Remove commented line. * Only allow getting a session when on Node11 or above. * Promisify methods.
2018-11-01 23:46:21 +01:00
* Given a function, returns the file, line and column number in the file where this function was
* defined. Returns { "", 0, 0 } if the location cannot be found or if the given function has no Script.
Mark internal APIs `@internal` to filter from API docs (#3809) Also: - Cleaned up existing tags so they're consistently at the bottom of doc comments where they should be - Cleaned up some unused imports while I was taking a pass over the files - Marked one function `@deprecated` that should be deprecated
2020-01-26 18:06:35 +01:00
* @internal
Implement scope chain free variable lookup in pure TypeScript (#1139) * Implement closure scope chain analysis in pure TypeScript This change makes use of four V8 intrinsics to avoid having to use a native module to inspect the scope chains of live Function objects. This unfortunately leads to the limitation of not allowing captures of 'this' in arrow functions, but that is something we are willing to live with for now. * Remove native module build and restore from the Makefile * CR feedback: Be a little more efficient when scanning the scope chain * Nuke everything related to custom Node versions and the native Node module * CR feedback: rename native.ts -> v8.ts, document some interfaces in v8.ts
2018-04-10 19:04:11 +02:00
*/
Get closure serialiation working in Node11 (#2101) * Make v8 primitives async as there is no way to avoid async in node11. * Simplify API. * Move processing of well-known globals into the v8 layer. We'll need this so that we can map from RemoteObjectIds back to these well known values. * Remove unnecesssary check. * Cleanup comments and extract helper. * Introduce helper bridge method for the simple case of making an entry for a string. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Make functions async. They'll need to be async once we move to the Inspector api. * Move property access behind helpers so they can move to the Inspector API in the future. * Only call function when we know we have a Function. Remove redundant null check. * Properly serialize certain special JavaScript number values that JSON serialization cannot handle. * Only marshall across the 'source' and 'flags' for a RegExp when serializing. * Add a simple test to validate a regex without flags. * Extract functionality into helper method. * Add test with complex output scenarios. * Output serialization needs to avoid recursively trying to serialize a serialized value. * Introduce indirection for introspecting properties of an object. * Use our own introspection API for examining an Array. * Hide direct property access through API indirection. * Produce values like the v8 Inspector does. * Compute the module map asynchronously. Will need that when mapping mirrors instead. * Cleanup a little code in closure creation. * Get serialization working on Node11 (except function locations). * Run tests in the same order on <v11 and >=v11 * Make tests run on multiple versions of node. * Rename file to make PR simpler to review. * Cleanup. * Be more careful with global state. * Remove commented line. * Only allow getting a session when on Node11 or above. * Promisify methods.
2018-11-01 23:46:21 +01:00
export const getFunctionLocationAsync = versionSpecificV8Module.getFunctionLocationAsync;
Reference in a new issue Copy permalink