public FunctionDefinition(NameExpression name, Parameter[] parameters, Statement body, DecoratorStatement decorators = null) { if (name == null) { _name = new NameExpression("<lambda>"); _isLambda = true; } else { _name = name; } _parameters = parameters; _body = body; _decorators = decorators; }
// decorators ::= // decorator+ // decorator ::= // "@" dotted_name ["(" [argument_list [","]] ")"] NEWLINE private DecoratorStatement ParseDecorators(out List<string> newlineWhiteSpace) { List<Expression> decorators = new List<Expression>(); newlineWhiteSpace = MakeWhiteSpaceList(); Eat(TokenKind.At); var decStart = GetStart(); do { if (newlineWhiteSpace != null) { newlineWhiteSpace.Add(_tokenWhiteSpace); } var start = GetStart(); var name = ReadName(); Expression decorator = MakeName(name); if (!name.HasName) { decorators.Add(null); continue; } if (_verbatim) { AddPreceedingWhiteSpace(decorator, _tokenWhiteSpace); } decorator.SetLoc(GetStart(), GetEnd()); while (MaybeEat(TokenKind.Dot)) { string whitespace = _tokenWhiteSpace; name = ReadNameMaybeNone(); if (!name.HasName) { decorator = Error(_verbatim ? (_tokenWhiteSpace + _token.Token.VerbatimImage + _lookaheadWhiteSpace + _lookahead.Token.VerbatimImage) : null, decorator); NextToken(); } else { string nameWhitespace = _tokenWhiteSpace; var memberDecorator = MakeMember(decorator, name); memberDecorator.SetLoc(start, GetStart(), GetEnd()); if (_verbatim) { AddPreceedingWhiteSpace(memberDecorator, whitespace); AddSecondPreceedingWhiteSpace(memberDecorator, nameWhitespace); } decorator = memberDecorator; } } if (MaybeEat(TokenKind.LeftParenthesis)) { string parenWhiteSpace = _tokenWhiteSpace; var commaWhiteSpace = MakeWhiteSpaceList(); bool ateTerminator; Arg[] args = FinishArgumentList(null, commaWhiteSpace, out ateTerminator); decorator = FinishCallExpr(decorator, args); if (_verbatim) { AddPreceedingWhiteSpace(decorator, parenWhiteSpace); AddSecondPreceedingWhiteSpace(decorator, _tokenWhiteSpace); if (commaWhiteSpace != null) { AddListWhiteSpace(decorator, commaWhiteSpace.ToArray()); } if (!ateTerminator) { AddErrorMissingCloseGrouping(decorator); } } decorator.SetLoc(start, GetEnd()); } string newline; EatNewLine(out newline); if (newlineWhiteSpace != null) { newlineWhiteSpace.Add(newline); } decorators.Add(decorator); } while (MaybeEat(TokenKind.At)); var res = new DecoratorStatement(decorators.ToArray()); res.SetLoc(decStart, GetEnd()); return res; }
// DecoratorStatement public override bool Walk(DecoratorStatement node) { return ShouldWalkWorker(node); }
public ExtractMethodResult GetExtractionResult(ExtractMethodRequest info) { bool isStaticMethod = false, isClassMethod = false; var parameters = new List<Parameter>(); string selfParam = null; if (info.TargetScope is ClassDefinition) { var fromScope = _scopes[_scopes.Length - 1] as FunctionDefinition; Debug.Assert(fromScope != null); // we don't allow extracting from classes, so we have to be coming from a function if (fromScope.Decorators != null) { foreach (var decorator in fromScope.Decorators.Decorators) { NameExpression name = decorator as NameExpression; if (name != null) { if (name.Name == "staticmethod") { isStaticMethod = true; } else if (name.Name == "classmethod") { isClassMethod = true; } } } } if (!isStaticMethod) { if (fromScope.Parameters.Count > 0) { selfParam = fromScope.Parameters[0].Name; parameters.Add(new Parameter(selfParam, ParameterKind.Normal)); } } } foreach (var param in info.Parameters) { var newParam = new Parameter(param, ParameterKind.Normal); if (parameters.Count > 0) { newParam.AddPreceedingWhiteSpace(_ast, " "); } parameters.Add(newParam); } // include any non-closed over parameters as well... foreach (var input in _inputVars) { var variableScope = input.Scope; var parentScope = info.TargetScope; // are these variables a child of the target scope so we can close over them? while (parentScope != null && parentScope != variableScope) { parentScope = parentScope.Parent; } if (parentScope == null && input.Name != selfParam) { // we can either close over or pass these in as parameters, add them to the list var newParam = new Parameter(input.Name, ParameterKind.Normal); if (parameters.Count > 0) { newParam.AddPreceedingWhiteSpace(_ast, " "); } parameters.Add(newParam); } } var body = _target.GetBody(_ast); if (_outputVars.Count > 0) { // need to add a return statement Expression retValue; Expression[] names = new Expression[_outputVars.Count]; int outputIndex = 0; foreach (var name in _outputVars) { var nameExpr = new NameExpression(name.Name); nameExpr.AddPreceedingWhiteSpace(_ast, " "); names[outputIndex++] = nameExpr; } var tuple = new TupleExpression(false, names); tuple.RoundTripHasNoParenthesis(_ast); retValue = tuple; var retStmt = new ReturnStatement(retValue); if (body is SuiteStatement) { SuiteStatement suite = (SuiteStatement)body; Node.CopyLeadingWhiteSpace(_ast, suite.Statements[0], retStmt); Node.CopyTrailingNewLine(_ast, suite.Statements[0], suite.Statements[suite.Statements.Count - 1]); Statement[] statements = new Statement[suite.Statements.Count + 1]; for (int i = 0; i < suite.Statements.Count; i++) { statements[i] = suite.Statements[i]; } statements[statements.Length - 1] = retStmt; body = new SuiteStatement(statements); } else { Node.CopyLeadingWhiteSpace(_ast, body, retStmt); body = new SuiteStatement( new Statement[] { body, retStmt } ); } } DecoratorStatement decorators = null; if (isStaticMethod) { decorators = new DecoratorStatement(new[] { new NameExpression("staticmethod") }); } else if (isClassMethod) { decorators = new DecoratorStatement(new[] { new NameExpression("classmethod") }); } var res = new FunctionDefinition(new NameExpression(info.Name), parameters.ToArray(), body, decorators); StringBuilder newCall = new StringBuilder(); newCall.Append(_target.IndentationLevel); var method = res.ToCodeString(_ast); // fix up indentation... for (int curScope = 0; curScope < _scopes.Length; curScope++) { if (_scopes[curScope] == info.TargetScope) { // this is our target indentation level. var indentationLevel = _scopes[curScope].Body.GetIndentationLevel(_ast); var lines = method.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None); int minWhiteSpace = Int32.MaxValue; for (int curLine = decorators == null ? 1 : 2; curLine < lines.Length; curLine++) { var line = lines[curLine]; for (int i = 0; i < line.Length; i++) { if (!Char.IsWhiteSpace(line[i])) { minWhiteSpace = Math.Min(minWhiteSpace, i); break; } } } StringBuilder newLines = new StringBuilder(); newLines.Append(indentationLevel); newLines.Append(lines[0]); if (decorators != null) { newLines.Append("\r\n"); newLines.Append(indentationLevel); newLines.Append(lines[1]); } // don't include a bunch of blank lines... int endLine = lines.Length - 1; for (; endLine >= 0 && String.IsNullOrWhiteSpace(lines[endLine]); endLine--) { } newLines.Append("\r\n"); for (int curLine = decorators == null ? 1 : 2; curLine <= endLine; curLine++) { var line = lines[curLine]; newLines.Append(indentationLevel); if (_insertTabs) { newLines.Append('\t'); } else { newLines.Append(' ', _indentSize); } if (line.Length > minWhiteSpace) { newLines.Append(line, minWhiteSpace, line.Length - minWhiteSpace); } newLines.Append("\r\n"); } newLines.Append("\r\n"); method = newLines.ToString(); break; } } string comma; if (_outputVars.Count > 0) { comma = ""; foreach (var outputVar in _outputVars) { newCall.Append(comma); newCall.Append(outputVar.Name); comma = ", "; } newCall.Append(" = "); } else if (_target.ContainsReturn) { newCall.Append("return "); } if (info.TargetScope is ClassDefinition) { var fromScope = _scopes[_scopes.Length - 1] as FunctionDefinition; Debug.Assert(fromScope != null); // we don't allow extracting from classes, so we have to be coming from a function if (isStaticMethod) { newCall.Append(info.TargetScope.Name); newCall.Append('.'); } else if (fromScope.Parameters.Count > 0) { newCall.Append(fromScope.Parameters[0].Name); newCall.Append('.'); } } newCall.Append(info.Name); newCall.Append('('); comma = ""; foreach (var param in parameters) { if (param.Name != selfParam) { newCall.Append(comma); newCall.Append(param.Name); comma = ", "; } } newCall.Append(')'); return new ExtractMethodResult( method, newCall.ToString() ); }
public override void PostWalk(DecoratorStatement node) { PostWalkWorker(node); }