diff options
Diffstat (limited to 'devtools/shared/webconsole/js-property-provider.js')
| -rw-r--r-- | devtools/shared/webconsole/js-property-provider.js | 803 |
1 files changed, 803 insertions, 0 deletions
diff --git a/devtools/shared/webconsole/js-property-provider.js b/devtools/shared/webconsole/js-property-provider.js new file mode 100644 index 0000000000..c261fed40d --- /dev/null +++ b/devtools/shared/webconsole/js-property-provider.js @@ -0,0 +1,803 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +const DevToolsUtils = require("resource://devtools/shared/DevToolsUtils.js"); + +const { + evalWithDebugger, +} = require("resource://devtools/server/actors/webconsole/eval-with-debugger.js"); + +if (!isWorker) { + loader.lazyRequireGetter( + this, + "getSyntaxTrees", + "resource://devtools/shared/webconsole/parser-helper.js", + true + ); +} +const lazy = {}; +ChromeUtils.defineESModuleGetters(lazy, { + Reflect: "resource://gre/modules/reflect.sys.mjs", +}); +loader.lazyRequireGetter( + this, + [ + "analyzeInputString", + "shouldInputBeAutocompleted", + "shouldInputBeEagerlyEvaluated", + ], + "resource://devtools/shared/webconsole/analyze-input-string.js", + true +); + +// Provide an easy way to bail out of even attempting an autocompletion +// if an object has way too many properties. Protects against large objects +// with numeric values that wouldn't be tallied towards MAX_AUTOCOMPLETIONS. +const MAX_AUTOCOMPLETE_ATTEMPTS = (exports.MAX_AUTOCOMPLETE_ATTEMPTS = 100000); +// Prevent iterating over too many properties during autocomplete suggestions. +const MAX_AUTOCOMPLETIONS = (exports.MAX_AUTOCOMPLETIONS = 1500); + +/** + * Provides a list of properties, that are possible matches based on the passed + * Debugger.Environment/Debugger.Object and inputValue. + * + * @param {Object} An object of the following shape: + * - {Object} dbgObject + * When the debugger is not paused this Debugger.Object wraps + * the scope for autocompletion. + * It is null if the debugger is paused. + * - {Object} environment + * When the debugger is paused this Debugger.Environment is the + * scope for autocompletion. + * It is null if the debugger is not paused. + * - {String} inputValue + * Value that should be completed. + * - {Number} cursor (defaults to inputValue.length). + * Optional offset in the input where the cursor is located. If this is + * omitted then the cursor is assumed to be at the end of the input + * value. + * - {Array} authorizedEvaluations (defaults to []). + * Optional array containing all the different properties access that the engine + * can execute in order to retrieve its result's properties. + * ⚠️ This should be set to true *ONLY* on user action as it may cause side-effects + * in the content page ⚠️ + * - {WebconsoleActor} webconsoleActor + * A reference to a webconsole actor which we can use to retrieve the last + * evaluation result or create a debuggee value. + * - {String}: selectedNodeActor + * The actor id of the selected node in the inspector. + * - {Array<string>}: expressionVars + * Optional array containing variable defined in the expression. Those variables + * are extracted from CodeMirror state. + * @returns null or object + * If the inputValue is an unsafe getter and invokeUnsafeGetter is false, the + * following form is returned: + * + * { + * isUnsafeGetter: true, + * getterPath: {Array<String>} An array of the property chain leading to the + * getter. Example: ["x", "myGetter"] + * } + * + * If no completion valued could be computed, and the input is not an unsafe + * getter, null is returned. + * + * Otherwise an object with the following form is returned: + * { + * matches: Set<string> + * matchProp: Last part of the inputValue that was used to find + * the matches-strings. + * isElementAccess: Boolean set to true if the evaluation is an element + * access (e.g. `window["addEvent`). + * } + */ +// eslint-disable-next-line complexity +function JSPropertyProvider({ + dbgObject, + environment, + frameActorId, + inputValue, + cursor, + authorizedEvaluations = [], + webconsoleActor, + selectedNodeActor, + expressionVars = [], +}) { + if (cursor === undefined) { + cursor = inputValue.length; + } + + inputValue = inputValue.substring(0, cursor); + + // Analyse the inputValue and find the beginning of the last part that + // should be completed. + const inputAnalysis = analyzeInputString(inputValue); + + if (!shouldInputBeAutocompleted(inputAnalysis)) { + return null; + } + + let { + lastStatement, + isElementAccess, + mainExpression, + matchProp, + isPropertyAccess, + } = inputAnalysis; + + // Eagerly evaluate the main expression and return the results properties. + // e.g. `obj.func().a` will evaluate `obj.func()` and return properties matching `a`. + // NOTE: this is only useful when the input has a property access. + if (webconsoleActor && shouldInputBeEagerlyEvaluated(inputAnalysis)) { + const eagerResponse = evalWithDebugger( + mainExpression, + { eager: true, selectedNodeActor, frameActor: frameActorId }, + webconsoleActor + ); + + const ret = eagerResponse?.result?.return; + + // Only send matches if eager evaluation returned something meaningful + if (ret && ret !== undefined) { + const matches = + typeof ret != "object" + ? getMatchedProps(ret, matchProp) + : getMatchedPropsInDbgObject(ret, matchProp); + + return prepareReturnedObject({ + matches, + search: matchProp, + isElementAccess, + }); + } + } + + // AST representation of the expression before the last access char (`.` or `[`). + let astExpression; + const startQuoteRegex = /^('|"|`)/; + const env = environment || dbgObject.asEnvironment(); + + // Catch literals like [1,2,3] or "foo" and return the matches from + // their prototypes. + // Don't run this is a worker, migrating to acorn should allow this + // to run in a worker - Bug 1217198. + if (!isWorker && isPropertyAccess) { + const syntaxTrees = getSyntaxTrees(mainExpression); + const lastTree = syntaxTrees[syntaxTrees.length - 1]; + const lastBody = lastTree?.body[lastTree.body.length - 1]; + + // Finding the last expression since we've sliced up until the dot. + // If there were parse errors this won't exist. + if (lastBody) { + if (!lastBody.expression) { + return null; + } + + astExpression = lastBody.expression; + let matchingObject; + + if (astExpression.type === "ArrayExpression") { + matchingObject = getContentPrototypeObject(env, "Array"); + } else if ( + astExpression.type === "Literal" && + typeof astExpression.value === "string" + ) { + matchingObject = getContentPrototypeObject(env, "String"); + } else if ( + astExpression.type === "Literal" && + Number.isFinite(astExpression.value) + ) { + // The parser rightfuly indicates that we have a number in some cases (e.g. `1.`), + // but we don't want to return Number proto properties in that case since + // the result would be invalid (i.e. `1.toFixed()` throws). + // So if the expression value is an integer, it should not end with `{Number}.` + // (but the following are fine: `1..`, `(1.).`). + if ( + !Number.isInteger(astExpression.value) || + /\d[^\.]{0}\.$/.test(lastStatement) === false + ) { + matchingObject = getContentPrototypeObject(env, "Number"); + } else { + return null; + } + } + + if (matchingObject) { + let search = matchProp; + + let elementAccessQuote; + if (isElementAccess && startQuoteRegex.test(matchProp)) { + elementAccessQuote = matchProp[0]; + search = matchProp.replace(startQuoteRegex, ""); + } + + let props = getMatchedPropsInDbgObject(matchingObject, search); + + if (isElementAccess) { + props = wrapMatchesInQuotes(props, elementAccessQuote); + } + + return { + isElementAccess, + matchProp, + matches: props, + }; + } + } + } + + // We are completing a variable / a property lookup. + let properties = []; + + if (astExpression) { + if (isPropertyAccess) { + properties = getPropertiesFromAstExpression(astExpression); + + if (properties === null) { + return null; + } + } + } else { + properties = lastStatement.split("."); + if (isElementAccess) { + const lastPart = properties[properties.length - 1]; + const openBracketIndex = lastPart.lastIndexOf("["); + matchProp = lastPart.substr(openBracketIndex + 1); + properties[properties.length - 1] = lastPart.substring( + 0, + openBracketIndex + ); + } else { + matchProp = properties.pop().trimLeft(); + } + } + + let search = matchProp; + let elementAccessQuote; + if (isElementAccess && startQuoteRegex.test(search)) { + elementAccessQuote = search[0]; + search = search.replace(startQuoteRegex, ""); + } + + let obj = dbgObject; + if (properties.length === 0) { + const environmentProperties = getMatchedPropsInEnvironment(env, search); + const expressionVariables = new Set( + expressionVars.filter(variableName => variableName.startsWith(matchProp)) + ); + + for (const prop of environmentProperties) { + expressionVariables.add(prop); + } + + return { + isElementAccess, + matchProp, + matches: expressionVariables, + }; + } + + let firstProp = properties.shift(); + if (typeof firstProp == "string") { + firstProp = firstProp.trim(); + } + + if (firstProp === "this") { + // Special case for 'this' - try to get the Object from the Environment. + // No problem if it throws, we will just not autocomplete. + try { + obj = env.object; + } catch (e) { + // Ignore. + } + } else if (firstProp === "$_" && webconsoleActor) { + obj = webconsoleActor.getLastConsoleInputEvaluation(); + } else if (firstProp === "$0" && selectedNodeActor && webconsoleActor) { + const actor = webconsoleActor.conn.getActor(selectedNodeActor); + if (actor) { + try { + obj = webconsoleActor.makeDebuggeeValue(actor.rawNode); + } catch (e) { + // Ignore. + } + } + } else if (hasArrayIndex(firstProp)) { + obj = getArrayMemberProperty(null, env, firstProp); + } else { + obj = getVariableInEnvironment(env, firstProp); + } + + if (!isObjectUsable(obj)) { + return null; + } + + // We get the rest of the properties recursively starting from the + // Debugger.Object that wraps the first property + for (let [index, prop] of properties.entries()) { + if (typeof prop === "string") { + prop = prop.trim(); + } + + if (prop === undefined || prop === null || prop === "") { + return null; + } + + const propPath = [firstProp].concat(properties.slice(0, index + 1)); + const authorized = authorizedEvaluations.some( + x => JSON.stringify(x) === JSON.stringify(propPath) + ); + + if (!authorized && DevToolsUtils.isUnsafeGetter(obj, prop)) { + // If we try to access an unsafe getter, return its name so we can consume that + // on the frontend. + return { + isUnsafeGetter: true, + getterPath: propPath, + }; + } + + if (hasArrayIndex(prop)) { + // The property to autocomplete is a member of array. For example + // list[i][j]..[n]. Traverse the array to get the actual element. + obj = getArrayMemberProperty(obj, null, prop); + } else { + obj = DevToolsUtils.getProperty(obj, prop, authorized); + } + + if (!isObjectUsable(obj)) { + return null; + } + } + + const matches = + typeof obj != "object" + ? getMatchedProps(obj, search) + : getMatchedPropsInDbgObject(obj, search); + return prepareReturnedObject({ + matches, + search, + isElementAccess, + elementAccessQuote, + }); +} + +function hasArrayIndex(str) { + return /\[\d+\]$/.test(str); +} + +/** + * For a given environment and constructor name, returns its Debugger.Object wrapped + * prototype. + * + * @param {Environment} env + * @param {String} name: Name of the constructor object we want the prototype of. + * @returns {Debugger.Object|null} the prototype, or null if it not found. + */ +function getContentPrototypeObject(env, name) { + // Retrieve the outermost environment to get the global object. + let outermostEnv = env; + while (outermostEnv?.parent) { + outermostEnv = outermostEnv.parent; + } + + const constructorObj = DevToolsUtils.getProperty(outermostEnv.object, name); + if (!constructorObj) { + return null; + } + + return DevToolsUtils.getProperty(constructorObj, "prototype"); +} + +/** + * @param {Object} ast: An AST representing a property access (e.g. `foo.bar["baz"].x`) + * @returns {Array|null} An array representing the property access + * (e.g. ["foo", "bar", "baz", "x"]). + */ +function getPropertiesFromAstExpression(ast) { + let result = []; + if (!ast) { + return result; + } + const { type, property, object, name, expression } = ast; + if (type === "ThisExpression") { + result.unshift("this"); + } else if (type === "Identifier" && name) { + result.unshift(name); + } else if (type === "OptionalExpression" && expression) { + result = (getPropertiesFromAstExpression(expression) || []).concat(result); + } else if ( + type === "MemberExpression" || + type === "OptionalMemberExpression" + ) { + if (property) { + if (property.type === "Identifier" && property.name) { + result.unshift(property.name); + } else if (property.type === "Literal") { + result.unshift(property.value); + } + } + if (object) { + result = (getPropertiesFromAstExpression(object) || []).concat(result); + } + } else { + return null; + } + return result; +} + +function wrapMatchesInQuotes(matches, quote = `"`) { + return new Set( + [...matches].map(p => { + // Escape as a double-quoted string literal + p = JSON.stringify(p); + + // We don't have to do anything more when using double quotes + if (quote == `"`) { + return p; + } + + // Remove surrounding double quotes + p = p.slice(1, -1); + + // Unescape inner double quotes (all must be escaped, so no need to count backslashes) + p = p.replace(/\\(?=")/g, ""); + + // Escape the specified quote (assuming ' or `, which are treated literally in regex) + p = p.replace(new RegExp(quote, "g"), "\\$&"); + + // Template literals treat ${ specially, escape it + if (quote == "`") { + p = p.replace(/\${/g, "\\$&"); + } + + // Surround the result with quotes + return `${quote}${p}${quote}`; + }) + ); +} + +/** + * Get the array member of obj for the given prop. For example, given + * prop='list[0][1]' the element at [0][1] of obj.list is returned. + * + * @param object obj + * The object to operate on. Should be null if env is passed. + * @param object env + * The Environment to operate in. Should be null if obj is passed. + * @param string prop + * The property to return. + * @return null or Object + * Returns null if the property couldn't be located. Otherwise the array + * member identified by prop. + */ +function getArrayMemberProperty(obj, env, prop) { + // First get the array. + const propWithoutIndices = prop.substr(0, prop.indexOf("[")); + + if (env) { + obj = getVariableInEnvironment(env, propWithoutIndices); + } else { + obj = DevToolsUtils.getProperty(obj, propWithoutIndices); + } + + if (!isObjectUsable(obj)) { + return null; + } + + // Then traverse the list of indices to get the actual element. + let result; + const arrayIndicesRegex = /\[[^\]]*\]/g; + while ((result = arrayIndicesRegex.exec(prop)) !== null) { + const indexWithBrackets = result[0]; + const indexAsText = indexWithBrackets.substr( + 1, + indexWithBrackets.length - 2 + ); + const index = parseInt(indexAsText, 10); + + if (isNaN(index)) { + return null; + } + + obj = DevToolsUtils.getProperty(obj, index); + + if (!isObjectUsable(obj)) { + return null; + } + } + + return obj; +} + +/** + * Check if the given Debugger.Object can be used for autocomplete. + * + * @param Debugger.Object object + * The Debugger.Object to check. + * @return boolean + * True if further inspection into the object is possible, or false + * otherwise. + */ +function isObjectUsable(object) { + if (object == null) { + return false; + } + + if (typeof object == "object" && object.class == "DeadObject") { + return false; + } + + return true; +} + +/** + * @see getExactMatchImpl() + */ +function getVariableInEnvironment(environment, name) { + return getExactMatchImpl(environment, name, DebuggerEnvironmentSupport); +} + +function prepareReturnedObject({ + matches, + search, + isElementAccess, + elementAccessQuote, +}) { + if (isElementAccess) { + // If it's an element access, we need to wrap properties in quotes (either the one + // the user already typed, or `"`). + + matches = wrapMatchesInQuotes(matches, elementAccessQuote); + } else if (!isWorker) { + // If we're not performing an element access, we need to check that the property + // are suited for a dot access. (reflect.sys.mjs is not available in worker context yet, + // see Bug 1507181). + for (const match of matches) { + try { + // In order to know if the property is suited for dot notation, we use Reflect + // to parse an expression where we try to access the property with a dot. If it + // throws, this means that we need to do an element access instead. + lazy.Reflect.parse(`({${match}: true})`); + } catch (e) { + matches.delete(match); + } + } + } + + return { isElementAccess, matchProp: search, matches }; +} + +/** + * @see getMatchedPropsImpl() + */ +function getMatchedPropsInEnvironment(environment, match) { + return getMatchedPropsImpl(environment, match, DebuggerEnvironmentSupport); +} + +/** + * @see getMatchedPropsImpl() + */ +function getMatchedPropsInDbgObject(dbgObject, match) { + return getMatchedPropsImpl(dbgObject, match, DebuggerObjectSupport); +} + +/** + * @see getMatchedPropsImpl() + */ +function getMatchedProps(obj, match) { + if (typeof obj != "object") { + obj = obj.constructor.prototype; + } + return getMatchedPropsImpl(obj, match, JSObjectSupport); +} + +/** + * Get all properties in the given object (and its parent prototype chain) that + * match a given prefix. + * + * @param {Mixed} obj + * Object whose properties we want to filter. + * @param {string} match + * Filter for properties that match this string. + * @returns {Set} List of matched properties. + */ +function getMatchedPropsImpl(obj, match, { chainIterator, getProperties }) { + const matches = new Set(); + let numProps = 0; + + const insensitiveMatching = match && match[0].toUpperCase() !== match[0]; + const propertyMatches = prop => { + return insensitiveMatching + ? prop.toLocaleLowerCase().startsWith(match.toLocaleLowerCase()) + : prop.startsWith(match); + }; + + // We need to go up the prototype chain. + const iter = chainIterator(obj); + for (obj of iter) { + const props = getProperties(obj); + if (!props) { + continue; + } + numProps += props.length; + + // If there are too many properties to event attempt autocompletion, + // or if we have already added the max number, then stop looping + // and return the partial set that has already been discovered. + if ( + numProps >= MAX_AUTOCOMPLETE_ATTEMPTS || + matches.size >= MAX_AUTOCOMPLETIONS + ) { + break; + } + + for (let i = 0; i < props.length; i++) { + const prop = props[i]; + if (!propertyMatches(prop)) { + continue; + } + + // If it is an array index, we can't take it. + // This uses a trick: converting a string to a number yields NaN if + // the operation failed, and NaN is not equal to itself. + // eslint-disable-next-line no-self-compare + if (+prop != +prop) { + matches.add(prop); + } + + if (matches.size >= MAX_AUTOCOMPLETIONS) { + break; + } + } + } + + return matches; +} + +/** + * Returns a property value based on its name from the given object, by + * recursively checking the object's prototype. + * + * @param object obj + * An object to look the property into. + * @param string name + * The property that is looked up. + * @returns object|undefined + * A Debugger.Object if the property exists in the object's prototype + * chain, undefined otherwise. + */ +function getExactMatchImpl(obj, name, { chainIterator, getProperty }) { + // We need to go up the prototype chain. + const iter = chainIterator(obj); + for (obj of iter) { + const prop = getProperty(obj, name, obj); + if (prop) { + return prop.value; + } + } + return undefined; +} + +var JSObjectSupport = { + *chainIterator(obj) { + while (obj) { + yield obj; + try { + obj = Object.getPrototypeOf(obj); + } catch (error) { + // The above can throw e.g. for some proxy objects. + return; + } + } + }, + + getProperties(obj) { + try { + return Object.getOwnPropertyNames(obj); + } catch (error) { + // The above can throw e.g. for some proxy objects. + return null; + } + }, + + getProperty() { + // getProperty is unsafe with raw JS objects. + throw new Error("Unimplemented!"); + }, +}; + +var DebuggerObjectSupport = { + *chainIterator(obj) { + while (obj) { + yield obj; + try { + // There could be transparent security wrappers, unwrap to check if it's a proxy. + const unwrapped = DevToolsUtils.unwrap(obj); + if (unwrapped === undefined) { + // Objects belonging to an invisible-to-debugger compartment can't be unwrapped. + return; + } + + if (unwrapped.isProxy) { + // Proxies might have a `getPrototypeOf` method, which is triggered by `obj.proto`, + // but this does not impact the actual prototype chain. + // In such case, we need to use the proxy target prototype. + // We retrieve proxyTarget from `obj` (and not `unwrapped`) to avoid exposing + // the unwrapped target. + obj = unwrapped.proxyTarget; + } + obj = obj.proto; + } catch (error) { + // The above can throw e.g. for some proxy objects. + return; + } + } + }, + + getProperties(obj) { + try { + return obj.getOwnPropertyNames(); + } catch (error) { + // The above can throw e.g. for some proxy objects. + return null; + } + }, + + getProperty(obj, name, rootObj) { + // This is left unimplemented in favor to DevToolsUtils.getProperty(). + throw new Error("Unimplemented!"); + }, +}; + +var DebuggerEnvironmentSupport = { + *chainIterator(obj) { + while (obj) { + yield obj; + obj = obj.parent; + } + }, + + getProperties(obj) { + const names = obj.names(); + + // Include 'this' in results (in sorted order) + for (let i = 0; i < names.length; i++) { + if (i === names.length - 1 || names[i + 1] > "this") { + names.splice(i + 1, 0, "this"); + break; + } + } + + return names; + }, + + getProperty(obj, name) { + let result; + // Try/catch since name can be anything, and getVariable throws if + // it's not a valid ECMAScript identifier name + try { + // TODO: we should use getVariableDescriptor() here - bug 725815. + result = obj.getVariable(name); + } catch (e) { + // Ignore. + } + + // FIXME: Need actual UI, bug 941287. + if ( + result == null || + (typeof result == "object" && + (result.optimizedOut || result.missingArguments)) + ) { + return null; + } + return { value: result }; + }, +}; + +exports.JSPropertyProvider = DevToolsUtils.makeInfallible(JSPropertyProvider); + +// Export a version that will throw (for tests) +exports.FallibleJSPropertyProvider = JSPropertyProvider; |