use of org.python.pydev.parser.jython.ast.FunctionDef in project Pydev by fabioz.
the class NoSelfChecker method beforeFunctionDef.
/**
* when a class is declared inside a function scope, it must start with self if it does
* not start with the self parameter, unless it has a staticmethod decoration or is
* later assigned to a staticmethod.
*
* @param node
*/
public void beforeFunctionDef(FunctionDef node) {
if (scope.peek().equals(Scope.SCOPE_TYPE_CLASS)) {
// let's check if we have to start with self or cls
boolean startsWithSelf = false;
boolean startsWithCls = false;
String received = "";
if (node.args != null) {
if (node.args.args.length > 0) {
exprType arg = node.args.args[0];
if (arg instanceof Name) {
Name n = (Name) arg;
if (n.id.equals("self")) {
startsWithSelf = true;
} else if (n.id.equals("cls")) {
startsWithCls = true;
}
received = n.id;
}
}
}
boolean isStaticMethod = false;
boolean isClassMethod = false;
if (node.decs != null) {
for (decoratorsType dec : node.decs) {
if (dec != null) {
String rep = NodeUtils.getRepresentationString(dec.func);
if (rep != null) {
if (rep.equals("staticmethod")) {
isStaticMethod = true;
} else if (rep.equals("classmethod")) {
isClassMethod = true;
}
}
}
}
}
ZopeInterfaceComputer zopeInterfaceComputer = zopeInterfaceComputers.peek();
// didn't have staticmethod decorator either
String rep = NodeUtils.getRepresentationString(node);
if (rep.equals("__new__")) {
// __new__ could start wit cls or self
if (!startsWithCls && !startsWithSelf) {
if (!zopeInterfaceComputer.isZopeInterface()) {
// zope check is more expensive, so, do as the last thing.
maybeNoSelfDefinedItems.peek().put(rep, new Tuple<Expected, FunctionDef>(new Expected("self or cls", received), node));
}
}
} else if (!startsWithSelf && !startsWithCls && !isStaticMethod && !isClassMethod) {
if (!zopeInterfaceComputer.isZopeInterface()) {
// zope check is more expensive, so, do as the last thing.
maybeNoSelfDefinedItems.peek().put(rep, new Tuple<Expected, FunctionDef>(new Expected("self", received), node));
}
} else if (startsWithCls && !isClassMethod && !isStaticMethod) {
String classBase = classBases.peek();
if (rep.equals("__init__") && "type".equals(classBase)) {
// ok, in this case, cls is expected
} else {
if (!zopeInterfaceComputer.isZopeInterface()) {
// zope check is more expensive, so, do as the last thing.
maybeNoSelfDefinedItems.peek().put(rep, new Tuple<Expected, FunctionDef>(new Expected("self", received), node));
}
}
}
}
scope.push(Scope.SCOPE_TYPE_METHOD);
}
use of org.python.pydev.parser.jython.ast.FunctionDef in project Pydev by fabioz.
the class PyRefactoringFindDefinition method findActualTokenFromImportFromDefinition.
/**
* Given some definition, find its actual token (if that's possible)
* @param request the original request
* @param tok the token we're looking for
* @param lFindInfo place to store info
* @param selected place to add the new definition (if found)
* @param d the definition found before (this function will only work if this definition
* @param completionCache all completions found previously
* @param searchForMethodParameterFromParticipants find definition for method parameters
* maps to an ImportFrom)
*
* @return true if we found a new definition (and false otherwise)
* @throws Exception
*/
private static boolean findActualTokenFromImportFromDefinition(IPythonNature nature, String tok, List<IDefinition> selected, Definition d, ICompletionState completionCache, boolean searchForMethodParameterFromParticipants) throws Exception {
boolean didFindNewDef = false;
Set<Tuple3<String, Integer, Integer>> whereWePassed = new HashSet<Tuple3<String, Integer, Integer>>();
// in an import..from, the last part will always be the token imported
tok = FullRepIterable.getLastPart(tok);
if (searchForMethodParameterFromParticipants) {
if (d.ast instanceof Name) {
Name name = (Name) d.ast;
if (name.ctx == Name.Param) {
if (d.scope != null && !d.scope.getScopeStack().empty()) {
Object peek = d.scope.getScopeStack().peek();
if (peek instanceof FunctionDef) {
IDefinition found = CompletionParticipantsHelper.findDefinitionForMethodParameterFromParticipants(d, nature, completionCache);
if (found != null) {
selected.add(found);
return true;
}
}
}
}
}
}
while (d.ast instanceof ImportFrom) {
IDefinition[] found = followDefinition(d, whereWePassed, tok, nature, completionCache);
if (found != null && found.length == 1) {
Tuple3<String, Integer, Integer> tupFromDefinition = getTupFromDefinition((Definition) found[0]);
if (tupFromDefinition == null) {
break;
}
didFindNewDef = true;
d = (Definition) found[0];
} else {
break;
}
}
if (didFindNewDef) {
selected.add(d);
}
return didFindNewDef;
}
use of org.python.pydev.parser.jython.ast.FunctionDef in project Pydev by fabioz.
the class FastDefinitionsParser method endScopesInStack.
private void endScopesInStack(int currLogicalCol) {
while (stack.size() > 0) {
NodeEntry peek = stack.peek();
if (peek.logicalColumn < currLogicalCol) {
break;
}
NodeEntry currNode = stack.pop();
currNode.onEndScope();
if (stack.size() > 0) {
NodeEntry parentNode = stack.peek();
if (parentNode.node instanceof FunctionDef) {
// Inside a function def, only deal with attributes (if func inside class)
if (currNode.node instanceof Assign) {
if (stack.size() > 1) {
Assign assign = (Assign) currNode.node;
exprType target = assign.targets[0];
if (target instanceof Attribute) {
NodeEntry parentParents = stack.peek(1);
if (parentParents.node instanceof ClassDef) {
parentNode.body.add(currNode.node);
}
}
}
}
} else if (parentNode.node instanceof ClassDef) {
parentNode.body.add(currNode.node);
} else {
String msg = "Did not expect to find item below node: " + parentNode.node + " (module: " + this.moduleName + " file: " + this.file + " row: " + row + ").";
if (throwErrorOnWarnings) {
throw new RuntimeException(msg);
} else {
Log.log(msg);
}
}
} else {
body.add(currNode.node);
}
}
}
use of org.python.pydev.parser.jython.ast.FunctionDef in project Pydev by fabioz.
the class FastParser method createFunctionDef.
private FunctionDef createFunctionDef(int lastReturnedLine, NameTok nameTok, int matchedCol) {
argumentsType args;
if (cythonParse) {
Name name = new Name("self", Name.Store, false);
exprType[] selfExprType = new exprType[] { name };
name.beginLine = lastReturnedLine + 1;
// 4 for 'def ' and 1 for '('
name.beginColumn = matchedCol + 1 + 4 + 1 + nameTok.id.length();
args = new argumentsType(selfExprType, null, null, EMTPY_EXPR_TYPE, null, null, null, null, null, null);
} else {
args = new argumentsType(EMTPY_EXPR_TYPE, null, null, EMTPY_EXPR_TYPE, null, null, null, null, null, null);
}
FunctionDef functionDef = new FunctionDef(nameTok, args, EMTPY_STMT_TYPE, EMTPY_DECORATORS_TYPE, null, false);
functionDef.beginLine = lastReturnedLine + 1;
functionDef.beginColumn = matchedCol + 1;
return functionDef;
}
use of org.python.pydev.parser.jython.ast.FunctionDef in project Pydev by fabioz.
the class NodeUtils method getRepresentationString.
/**
* @param node this is the node from whom we want to get the representation
* @return A suitable String representation for some node.
*/
public static String getRepresentationString(SimpleNode node, boolean useTypeRepr) {
if (node instanceof NameTok) {
NameTok tok = (NameTok) node;
return tok.id;
}
if (node instanceof Name) {
Name name = (Name) node;
return name.id;
}
if (node instanceof aliasType) {
aliasType type = (aliasType) node;
return ((NameTok) type.name).id;
}
if (node instanceof Attribute) {
Attribute attribute = (Attribute) node;
return discoverRep(attribute.attr);
}
if (node instanceof keywordType) {
keywordType type = (keywordType) node;
return discoverRep(type.arg);
}
if (node instanceof ClassDef) {
ClassDef def = (ClassDef) node;
return ((NameTok) def.name).id;
}
if (node instanceof FunctionDef) {
FunctionDef def = (FunctionDef) node;
return ((NameTok) def.name).id;
}
if (node instanceof Call) {
Call call = ((Call) node);
return getRepresentationString(call.func, useTypeRepr);
}
if (node instanceof org.python.pydev.parser.jython.ast.List || node instanceof ListComp) {
String val = "[]";
if (useTypeRepr) {
val = getBuiltinType(val);
}
return val;
}
if (node instanceof org.python.pydev.parser.jython.ast.Dict || node instanceof org.python.pydev.parser.jython.ast.DictComp) {
String val = "{}";
if (useTypeRepr) {
val = getBuiltinType(val);
}
return val;
}
if (node instanceof BinOp) {
BinOp binOp = (BinOp) node;
if (binOp.left instanceof Str && binOp.op == BinOp.Mod) {
node = binOp.left;
// Just change the node... the check below will work with the Str already.
}
}
if (node instanceof Str) {
String val;
if (useTypeRepr) {
val = getBuiltinType("''");
} else {
val = "'" + ((Str) node).s + "'";
}
return val;
}
if (node instanceof Tuple) {
StringBuffer buf = new StringBuffer();
Tuple t = (Tuple) node;
for (exprType e : t.elts) {
buf.append(getRepresentationString(e, useTypeRepr));
buf.append(", ");
}
if (t.elts.length > 0) {
int l = buf.length();
buf.deleteCharAt(l - 1);
buf.deleteCharAt(l - 2);
}
String val = "(" + buf + ")";
if (useTypeRepr) {
val = getBuiltinType(val);
}
return val;
}
if (node instanceof Num) {
String val = ((Num) node).n.toString();
if (useTypeRepr) {
val = getBuiltinType(val);
}
return val;
}
if (node instanceof Import) {
aliasType[] names = ((Import) node).names;
for (aliasType n : names) {
if (n.asname != null) {
return ((NameTok) n.asname).id;
}
return ((NameTok) n.name).id;
}
}
if (node instanceof commentType) {
commentType type = (commentType) node;
return type.id;
}
if (node instanceof excepthandlerType) {
excepthandlerType type = (excepthandlerType) node;
return type.name.toString();
}
return null;
}
Aggregations