kopia lustrzana https://github.com/c9/core
410 wiersze
17 KiB
JavaScript
410 wiersze
17 KiB
JavaScript
define(function(require, exports, module) {
|
|
|
|
var baseLanguageHandler = require('plugins/c9.ide.language/base_handler');
|
|
var infer = require('./infer');
|
|
var path = require('./path');
|
|
var KIND_DEFAULT = require('plugins/c9.ide.language.javascript/scope_analyzer').KIND_DEFAULT;
|
|
var KIND_PACKAGE = require('plugins/c9.ide.language.javascript/scope_analyzer').KIND_PACKAGE;
|
|
var KIND_EVENT = require('plugins/c9.ide.language.javascript/scope_analyzer').KIND_EVENT;
|
|
var PROPER = require('plugins/c9.ide.language.javascript/scope_analyzer').PROPER;
|
|
var EXPAND_STRING = 1;
|
|
var EXPAND_REQUIRE = 2;
|
|
var EXPAND_REQUIRE_LIMIT = 5;
|
|
var REQUIRE_PROPOSALS_MAX = 80;
|
|
var REQUIRE_ID_REGEX = /(?!["'])./;
|
|
var FunctionValue = require('./values').FunctionValue;
|
|
var completeUtil = require("plugins/c9.ide.language/complete_util");
|
|
var traverse = require("treehugger/traverse");
|
|
var args = require("./infer_arguments");
|
|
var astUpdater = require("./ast_updater");
|
|
|
|
// Completion priority levels
|
|
// Should be used sparingly, since they disrupt the sorting order
|
|
var PRIORITY_INFER_LOW = 3;
|
|
var PRIORITY_INFER = 4;
|
|
var PRIORITY_INFER_TERN = 5;
|
|
var PRIORITY_INFER_HIGH = 6;
|
|
|
|
var completer = module.exports = Object.create(baseLanguageHandler);
|
|
var extraModuleCompletions;
|
|
|
|
completer.handlesLanguage = function(language) {
|
|
// Note that we don't really support jsx here,
|
|
// but rather tolerate it using error recovery...
|
|
return language === "javascript" || language === "jsx";
|
|
};
|
|
|
|
completer.getIdentifierRegex = function() {
|
|
// Allow slashes for package names
|
|
return (/[a-zA-Z_0-9\$\/]/);
|
|
};
|
|
|
|
completer.getCompletionRegex = function() {
|
|
return (/^[\.]$/);
|
|
};
|
|
|
|
completer.getCacheCompletionRegex = function() {
|
|
// Match strings that can be an expression or its prefix
|
|
return new RegExp(
|
|
// 'if/while/for ('
|
|
"(\\b(if|while|for|switch)\\s*\\("
|
|
// other identifiers and keywords without (
|
|
+ "|\\b\\w+\\s+"
|
|
// equality operators, operators such as + and -,
|
|
// and opening brackets { and [
|
|
+ "|(===?|!==?|[-+]=|[-+*%<>?!|&{[])"
|
|
// spaces
|
|
+ "|\\s)+"
|
|
);
|
|
};
|
|
|
|
completer.getMaxFileSizeSupported = function() {
|
|
// .25 of current base_handler default
|
|
return .25 * 10 * 1000 * 80;
|
|
};
|
|
|
|
completer.setExtraModules = function(extraModules) {
|
|
extraModuleCompletions = extraModules;
|
|
};
|
|
|
|
function valueToMatch(container, v, name, isPackage, isContextual) {
|
|
// Node.js and the default behavior of require.js is not adding the .js extension
|
|
if (isPackage)
|
|
name = name.replace(/\.js$/, "");
|
|
if ((v instanceof FunctionValue || v.properties._return) && !isPackage) {
|
|
var showArgs = args.extractArgumentNames(v, true);
|
|
var insertArgs = "opt" in showArgs ? args.extractArgumentNames(v, false) : showArgs;
|
|
return {
|
|
id: name,
|
|
guid: v.guid + "[0" + name + "]",
|
|
name: name + "(" + showArgs.argNames.join(", ") + ")",
|
|
replaceText: name + (insertArgs.argNames.length === 0 && v.guid && v.guid.indexOf("es5:") !== 0 ? "()" : "(^^)"),
|
|
icon: "method",
|
|
priority: PRIORITY_INFER,
|
|
inferredNames: showArgs.inferredNames,
|
|
doc: v.doc,
|
|
docUrl: v.docUrl,
|
|
isFunction: true,
|
|
type: v.properties._return && getGuid(v.properties._return.values[0]),
|
|
isContextual: isContextual
|
|
};
|
|
}
|
|
else {
|
|
var isHighConfidence =
|
|
container && container.properties && container.properties["_" + name]
|
|
&& container.properties["_" + name].confidence >= 1;
|
|
return {
|
|
id: name,
|
|
guid: container ? container.guid + "/" + name : v.guid + "[0" + name + "]",
|
|
name: name,
|
|
replaceText: name,
|
|
doc: v.doc,
|
|
docUrl: v.docUrl,
|
|
icon: "property",
|
|
priority: name === "__proto__" ? PRIORITY_INFER_LOW : PRIORITY_INFER,
|
|
type: !isPackage && getGuid(v.properties.___proto__ ? v.properties.___proto__.values[0] : v.guid),
|
|
isContextual: isHighConfidence
|
|
};
|
|
}
|
|
}
|
|
|
|
function getGuid(valueOrGuid) {
|
|
if (!valueOrGuid)
|
|
return;
|
|
var result = valueOrGuid.guid || valueOrGuid;
|
|
return result.substr && result.substr(-11) !== "/implReturn" ? result : undefined;
|
|
}
|
|
|
|
completer.predictNextCompletion = function(doc, fullAst, pos, options, callback) {
|
|
if (!options.matches.length) {
|
|
// Normally we wouldn't complete here, maybe we can complete for the next char?
|
|
// Let's do so unless it looks like the next char may be a newline or equals sign
|
|
if (options.line[pos.column - 1] && /(?![{;})\]\s"'\+\-\*])./.test(options.line[pos.column - 1]))
|
|
return callback(null, { predicted: "" });
|
|
}
|
|
var predicted = options.matches.filter(function(m) {
|
|
return m.priority >= PRIORITY_INFER;
|
|
});
|
|
if (predicted.length !== 1 || predicted[0].icon === "method")
|
|
return callback();
|
|
callback(null, {
|
|
predicted: predicted[0].replaceText + ".",
|
|
showEarly: predicted[0].icon === "property" && !/\./.test(options.line)
|
|
});
|
|
};
|
|
|
|
completer.complete = function(doc, fullAst, pos, options, callback) {
|
|
if (!options.node)
|
|
return callback();
|
|
var line = options.line;
|
|
var identifier = options.identifierPrefix;
|
|
var basePath = path.getBasePath(completer.path, completer.workspaceDir);
|
|
var filePath = path.canonicalizePath(completer.path, basePath);
|
|
if (fullAst.parent === undefined) {
|
|
traverse.addParentPointers(fullAst);
|
|
fullAst.parent = null;
|
|
}
|
|
astUpdater.updateOrReanalyze(doc, fullAst, filePath, basePath, pos, function(fullAst, currentNode) {
|
|
var completions = {};
|
|
var duplicates = {};
|
|
currentNode.rewrite(
|
|
'PropAccess(e, x)', function(b) {
|
|
var allIdentifiers = [];
|
|
var values = infer.inferValues(b.e);
|
|
values.forEach(function(v) {
|
|
var propNames = v.getPropertyNames();
|
|
for (var i = 0; i < propNames.length; i++) {
|
|
if (propNames[i] !== b.x.value || v.isProperDeclaration(propNames[i]))
|
|
allIdentifiers.push(propNames[i]);
|
|
}
|
|
});
|
|
var matches = completeUtil.findCompletions(identifier, allIdentifiers);
|
|
for (var i = 0; i < matches.length; i++) {
|
|
values.forEach(function(v) {
|
|
v.get(matches[i]).forEach(function(propVal) {
|
|
var match = valueToMatch(v, propVal, matches[i], false, true);
|
|
// Only override completion if argument names were _not_ inferred, or if no better match is known
|
|
var duplicate = duplicates["_" + match.id];
|
|
if (duplicate && duplicate.inferredNames)
|
|
delete completions["_" + duplicate.guid];
|
|
if (duplicate && match.inferredNames)
|
|
return;
|
|
duplicates["_" + match.id] = completions["_" + match.guid] = match;
|
|
});
|
|
});
|
|
}
|
|
return this;
|
|
},
|
|
// Don't complete definitions
|
|
'FArg(_)', 'Function(_,_,_)', 'VarDeclInit(_,_)', 'VarDecl(_,_)',
|
|
'ConstDeclInit(_,_)', 'ConstDecl(_,_)', function() { return this; },
|
|
'_', function() {
|
|
var me = this;
|
|
if (this.traverseUp(
|
|
"Call(Var(\"require\"), args)",
|
|
function(b) {
|
|
if (b.args[0] !== me && this !== me)
|
|
return;
|
|
var scope = this[0].getAnnotation("scope");
|
|
var expand = b.args[0] && b.args[0].cons === "String" ? null : EXPAND_STRING;
|
|
identifier = completeUtil.retrievePrecedingIdentifier(line, pos.column, REQUIRE_ID_REGEX);
|
|
|
|
var useBasePath = path.isRelativePath(identifier) || path.isAbsolutePath(identifier) ? basePath : null;
|
|
completer.proposeRequire(identifier, expand, scope, completions, useBasePath);
|
|
}))
|
|
return this;
|
|
},
|
|
'ERROR()', 'PropertyInit(x,e)', 'ObjectInit(ps)', function(b, node) {
|
|
if (b.ps) {
|
|
completer.proposeObjectProperty(node, identifier, completions);
|
|
}
|
|
else if (!b.x) {
|
|
if (currentNode.parent.cons !== "PropertyInit")
|
|
return; // Fallthrough
|
|
currentNode = currentNode.parent;
|
|
b.x = currentNode[0];
|
|
b.e = currentNode[1];
|
|
}
|
|
// get parent parent like in ObjectInit([PropertyInit("b",ERROR())])
|
|
var objectInit = currentNode.parent.parent;
|
|
if (!objectInit.parent || !objectInit.parent.parent || objectInit.parent.parent.cons !== "Call")
|
|
return node;
|
|
completer.proposeObjectProperty(objectInit, identifier, completions);
|
|
return node;
|
|
},
|
|
'Call(_, _)', function(b) {
|
|
if ("function".indexOf(identifier) === 0)
|
|
completer.proposeClosure(this, doc, pos, completions);
|
|
// Fallthrough to next rule
|
|
},
|
|
'Var(_)', function(b) {
|
|
if (this.parent.parent && this.parent.parent.isMatch('Call(_, _)') && "function".indexOf(identifier) === 0)
|
|
completer.proposeClosure(this.parent.parent, doc, pos, completions);
|
|
// Fallthrough to next rule
|
|
},
|
|
'Var(_)', function(b) {
|
|
this.parent.rewrite('VarDeclInit(x, _)', 'ConstDeclInit(x, _)', function(b) {
|
|
if ("require".indexOf(identifier) !== 0)
|
|
return;
|
|
var scope = this.getAnnotation("scope");
|
|
// Propose relative and non-relative paths
|
|
completer.proposeRequire(b.x.value, EXPAND_REQUIRE, scope, completions);
|
|
completer.proposeRequire(b.x.value, EXPAND_REQUIRE, scope, completions, basePath);
|
|
});
|
|
// Fallthrough to next rule
|
|
},
|
|
// Else, let's assume it's a variable
|
|
function() {
|
|
var scope;
|
|
this.traverseUp(function() {
|
|
if (!scope) scope = this.getAnnotation("scope");
|
|
if (this.rewrite("String(_)")) return this;
|
|
});
|
|
if (!scope)
|
|
return;
|
|
var variableNames = scope.getVariableNames();
|
|
if (this.cons === 'Var') { // Delete current var from proposals if not properly declared anywhere
|
|
var varName = this[0].value;
|
|
if (variableNames.indexOf(varName) !== -1 && (!scope.get(varName) || !scope.get(varName).isProperDeclaration()))
|
|
variableNames.splice(variableNames.indexOf(varName), 1);
|
|
}
|
|
var matches = completeUtil.findCompletions(identifier, variableNames);
|
|
for (var i = 0; i < matches.length; i++) {
|
|
var v = scope.get(matches[i]);
|
|
if (!v)
|
|
continue;
|
|
if (!v.values.length && v.properDeclarationConfidence >= PROPER && currentNode.cons === "Var") {
|
|
completions[matches[i]] = {
|
|
id: matches[i],
|
|
name: matches[i],
|
|
replaceText: matches[i],
|
|
icon: "property",
|
|
priority: PRIORITY_INFER_TERN
|
|
};
|
|
}
|
|
v.values.forEach(function(propVal) {
|
|
var match = valueToMatch(null, propVal, matches[i]);
|
|
if (!match.name)
|
|
return;
|
|
// Only override completion if argument names were _not_ inferred, or if no better match is known
|
|
var duplicate = duplicates["_" + match.id];
|
|
if (duplicate && duplicate.inferredNames)
|
|
delete completions["_" + duplicate.guid];
|
|
if (duplicate && match.inferredNames)
|
|
return;
|
|
duplicates["_" + match.id] = completions["_" + match.guid] = match;
|
|
});
|
|
}
|
|
}
|
|
);
|
|
// Find completions equal to the current prefix
|
|
var completionsArray = [];
|
|
for (var id in completions) {
|
|
completionsArray.push(completions[id]);
|
|
}
|
|
callback(completionsArray);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @param basePath If specified, the base path to use for relative paths.
|
|
* Enables listing relative paths.
|
|
*/
|
|
completer.proposeRequire = function(identifier, expand, scope, completions, basePath) {
|
|
var names = scope.getNamesByKind(KIND_PACKAGE);
|
|
|
|
if (basePath || basePath === "")
|
|
identifier = path.canonicalizePath(identifier, basePath).replace(/^\.$/, "");
|
|
|
|
if (expand === EXPAND_REQUIRE && extraModuleCompletions)
|
|
names = names.concat(Object.keys(extraModuleCompletions));
|
|
|
|
var matches = expand === EXPAND_REQUIRE
|
|
? filterRequireSubstring(identifier, names)
|
|
: completeUtil.findCompletions(identifier === "/" ? "" : identifier, names);
|
|
|
|
if (basePath || basePath === "")
|
|
matches = matches.filter(function(v) { return v.match(/\.js$/) && !v.match(/(\/|^)node_modules\//); });
|
|
else
|
|
matches = matches.filter(function(v) { return !v.match(/\.js$/); });
|
|
|
|
if (expand === EXPAND_REQUIRE && matches.length > EXPAND_REQUIRE_LIMIT)
|
|
return;
|
|
|
|
matches = matches.slice(0, REQUIRE_PROPOSALS_MAX);
|
|
|
|
for (var i = 0; i < matches.length; i++) {
|
|
var match = matches[i];
|
|
var v = scope.get(match, KIND_PACKAGE);
|
|
if (!v && expand === EXPAND_REQUIRE) {
|
|
return completions["_" + match] = {
|
|
id: match,
|
|
icon: "package",
|
|
name: 'require("' + match + '")',
|
|
replaceText: 'require("' + match + '")',
|
|
doc: "Origin: node<br/>"
|
|
+ (extraModuleCompletions[match].doc || ""),
|
|
priority: PRIORITY_INFER_HIGH
|
|
};
|
|
}
|
|
v.values.forEach(function(propVal) {
|
|
var match = valueToMatch(null, propVal, matches[i], true, expand);
|
|
match.icon = "package";
|
|
if (identifier.match(/^\//))
|
|
match.replaceText = match.name = "/" + match.replaceText;
|
|
else if (basePath || basePath === "")
|
|
match.replaceText = match.name = path.uncanonicalizePath(match.replaceText, basePath);
|
|
completions["_" + match.guid] = match;
|
|
if (expand === EXPAND_REQUIRE) {
|
|
match.replaceText = 'require("' + match.replaceText + '")';
|
|
match.name = 'require("' + match.name + '")';
|
|
}
|
|
if (expand === EXPAND_STRING)
|
|
match.replaceText = '"' + match.replaceText + '"';
|
|
if (expand !== EXPAND_REQUIRE)
|
|
match.identifierRegex = REQUIRE_ID_REGEX;
|
|
});
|
|
}
|
|
};
|
|
|
|
completer.proposeClosure = function(node, doc, pos, completions) {
|
|
node.rewrite('Call(f, args)', function(b) {
|
|
var argIndex = args.getArgIndex(this, doc, pos);
|
|
var id = 0;
|
|
infer.inferValues(b.f).forEach(function(v) {
|
|
var argNames = args.extractArgumentNames(v, false);
|
|
var code = argNames.argValueCodes[argIndex];
|
|
if (!code)
|
|
return;
|
|
var codeName = code.split(/\n/)[0] + "}";
|
|
var guid = v.guid + "-argfun" + (id++);
|
|
completions[guid] = {
|
|
id: codeName,
|
|
guid: guid,
|
|
name: codeName,
|
|
replaceText: code,
|
|
doc: v.fargs && v.fargs.doc,
|
|
docUrl: v.fargs && v.fargs.docUrl,
|
|
icon: "method",
|
|
priority: PRIORITY_INFER_HIGH
|
|
};
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Complete properties for an Object init in e.g.
|
|
* Call(PropAccess(Var("http"),"example"),[ObjectInit([PropertyInit("b",ERROR())])])
|
|
*/
|
|
completer.proposeObjectProperty = function(objectInit, identifier, completions) {
|
|
var listIndex;
|
|
for (var i = 0; i < objectInit.parent.length; i++)
|
|
if (objectInit.parent[i] === objectInit) listIndex = i;
|
|
var call = objectInit.parent.parent;
|
|
infer.inferValues(call[0]).forEach(function(v) {
|
|
if (!v.fargs || !v.fargs[listIndex] || !v.fargs[listIndex].properties)
|
|
return;
|
|
v.fargs[listIndex].properties.forEach(function(property) {
|
|
completions["_$p$" + property.id] = {
|
|
id: property.id,
|
|
name: property.id,
|
|
replaceText: property.id,
|
|
doc: property.doc,
|
|
docUrl: property.docUrl,
|
|
icon: "property",
|
|
priority: PRIORITY_INFER
|
|
};
|
|
});
|
|
});
|
|
};
|
|
|
|
function filterRequireSubstring(name, names) {
|
|
var nameClean = name.replace(/[^A-Za-z0-9_-]/g, ".");
|
|
var nameRegex = new RegExp("^" + nameClean + "\\b|\\b" + nameClean + "$");
|
|
return names.filter(function(n) {
|
|
return nameRegex.test(n);
|
|
});
|
|
}
|
|
|
|
});
|