internal override void AppendCodeStringStmt(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
_left.AppendCodeString(res, ast, format);
res.Append(this.GetProceedingWhiteSpace(ast));
res.Append(_op.ToCodeString());
res.Append('=');
_right.AppendCodeString(res, ast, format);
}
internal override void AppendCodeStringStmt(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
format.ReflowComment(res, this.GetProceedingWhiteSpace(ast));
res.Append("with");
var itemWhiteSpace = this.GetListWhiteSpace(ast);
int whiteSpaceIndex = 0;
for (int i = 0; i < _items.Length; i++) {
var item = _items[i];
if (i != 0) {
if (itemWhiteSpace != null) {
res.Append(itemWhiteSpace[whiteSpaceIndex++]);
}
res.Append(',');
}
item.ContextManager.AppendCodeString(res, ast, format);
if (item.Variable != null) {
if (itemWhiteSpace != null) {
res.Append(itemWhiteSpace[whiteSpaceIndex++]);
} else {
res.Append(' ');
}
res.Append("as");
item.Variable.AppendCodeString(res, ast, format);
}
}
_body.AppendCodeString(res, ast, format);
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
Target.AppendCodeString(res, ast, format);
format.Append(
res,
format.SpaceBeforeIndexBracket,
" ",
"",
this.GetProceedingWhiteSpace(ast)
);
res.Append('[');
_index.AppendCodeString(
res,
ast,
format,
format.SpaceWithinIndexBrackets != null ? format.SpaceWithinIndexBrackets.Value ? " " : "" : null
);
if (!this.IsMissingCloseGrouping(ast)) {
format.Append(
res,
format.SpaceWithinIndexBrackets,
" ",
"",
this.GetSecondWhiteSpace(ast)
);
res.Append(']');
}
}
public override string GetLeadingWhiteSpace(PythonAst ast) {
var whitespace = this.GetListWhiteSpace(ast);
if (whitespace != null && whitespace.Length > 0) {
return whitespace[0];
}
return null;
}
public override bool Walk(PythonAst node) {
if (_ast != node) {
throw new InvalidOperationException("walking wrong AST");
}
_scope.Push(_members);
return base.Walk(node);
}
public override string GetLeadingWhiteSpace(PythonAst ast) {
var decorateWhiteSpace = this.GetNamesWhiteSpace(ast);
if (decorateWhiteSpace != null && decorateWhiteSpace.Length > 0) {
return decorateWhiteSpace[0];
}
return "";
}
public override void SetLeadingWhiteSpace(PythonAst ast, string whiteSpace) {
var decorateWhiteSpace = this.GetNamesWhiteSpace(ast);
if (decorateWhiteSpace != null && decorateWhiteSpace.Length > 0) {
decorateWhiteSpace[0] = whiteSpace;
}
}
public MethodExtractor(IServiceProvider serviceProvider, ITextView textView) {
_view = textView;
_serviceProvider = serviceProvider;
var snapshot = _view.TextBuffer.CurrentSnapshot;
_ast = _view.GetAnalyzer(_serviceProvider).ParseSnapshot(snapshot);
}
internal static IEnumerable<IScopeNode> EnumerateBody(PythonAst ast, Statement body, bool includeAssignments = true) {
SuiteStatement suite = body as SuiteStatement;
if (suite != null) {
foreach (Statement stmt in suite.Statements) {
ClassDefinition klass = stmt as ClassDefinition;
if (klass != null) {
yield return new ClassScopeNode(klass);
continue;
}
FunctionDefinition func = stmt as FunctionDefinition;
if (func != null) {
yield return new FunctionScopeNode(func);
continue;
}
AssignmentStatement assign;
if (includeAssignments && (assign = stmt as AssignmentStatement) != null) {
foreach (var target in assign.Left) {
NameExpression name = target as NameExpression;
if (name != null) {
yield return new AssignmentScopeNode(ast, assign, name);
}
}
}
}
}
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
Expression left = _left;
Expression right = _right;
string op1, op2;
if (Operator == PythonOperator.NotIn) {
op1 = "not";
if (!this.IsIncompleteNode(ast)) {
op2 = "in";
} else {
op2 = null;
}
} else if (Operator == PythonOperator.IsNot) {
op1 = "is";
op2 = "not";
} else if ((op1 = this.GetVerbatimImage(ast)) != null) {
// operator image differs from the operator enum, for example <> is always NotEqual which is !=
// so we store the verbatim image and use it here.
op2 = null;
} else {
op1 = Operator.ToCodeString();
op2 = null;
}
BinaryToCodeString(res, ast, format, this, _left, _right, op1, op2);
}
public override void SetLeadingWhiteSpace(PythonAst ast, string whiteSpace) {
if (this.IsAltForm(ast)) {
Items[0].SetLeadingWhiteSpace(ast, whiteSpace);
} else {
base.SetLeadingWhiteSpace(ast, whiteSpace);
}
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format, string leadingWhiteSpace) {
string kwOnlyText = this.GetExtraVerbatimText(ast);
if (kwOnlyText != null) {
if (leadingWhiteSpace != null) {
res.Append(leadingWhiteSpace);
res.Append(kwOnlyText.TrimStart());
leadingWhiteSpace = null;
} else {
res.Append(kwOnlyText);
}
}
bool isAltForm = this.IsAltForm(ast);
if (isAltForm) {
res.Append(leadingWhiteSpace ?? this.GetProceedingWhiteSpace(ast));
res.Append('(');
leadingWhiteSpace = null;
}
_error.AppendCodeString(res, ast, format, leadingWhiteSpace);
if (this.DefaultValue != null) {
res.Append(this.GetSecondWhiteSpace(ast));
res.Append('=');
this.DefaultValue.AppendCodeString(res, ast, format);
}
if (isAltForm && !this.IsMissingCloseGrouping(ast)) {
res.Append(this.GetSecondWhiteSpace(ast));
res.Append(')');
}
}
public void UpdateTree(PythonAst newAst, IAnalysisCookie newCookie) {
lock (this) {
if (_updatesPending > 0) {
_updatesPending--;
}
if (newAst == null) {
// there was an error in parsing, just let the waiter go...
if (_curWaiter != null) {
_curWaiter.Set();
}
_tree = null;
return;
}
_tree = newAst;
_cookie = newCookie;
if (_curWaiter != null) {
_curWaiter.Set();
}
}
var newParse = OnNewParseTree;
if (newParse != null) {
newParse(this, EventArgs.Empty);
}
}
public override void SetLeadingWhiteSpace(PythonAst ast, string whiteSpace)
{
var itemWhiteSpace = this.GetListWhiteSpace(ast);
if (itemWhiteSpace != null && itemWhiteSpace.Length > 0) {
itemWhiteSpace[0] = whiteSpace;
}
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
if (this.IsAltForm(ast)) {
this.AppendCodeString(res, ast, format, "", "", _item);
} else {
this.AppendCodeString(res, ast, format, "(", this.IsMissingCloseGrouping(ast) ? "" : ")", _item);
}
}
public CoverageMapper(PythonAst ast, string filename, HashSet<int> hits) {
_ast = ast;
_filename = filename;
GlobalScope = new CoverageScope(ast);
CurScopes.Add(GlobalScope);
_blockCount++;
_hits = hits;
}
public ImportRemover(IServiceProvider serviceProvider, ITextView textView, bool allScopes) {
_view = textView;
_serviceProvider = serviceProvider;
var snapshot = _view.TextBuffer.CurrentSnapshot;
_ast = _view.GetAnalyzer(_serviceProvider).ParseSnapshot(snapshot);
_allScopes = allScopes;
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
format.ReflowComment(res, this.GetProceedingWhiteSpaceDefaultNull(ast));
if (format.UseVerbatimImage) {
res.Append(this.GetVerbatimImage(ast) ?? _name);
} else {
res.Append(_name);
}
}
public AstPythonParameterInfo(PythonAst ast, Parameter p) {
Name = p.Name;
Documentation = "";
DefaultValue = p.DefaultValue?.ToCodeString(ast) ?? "";
IsParamArray = p.Kind == ParameterKind.List;
IsKeywordDict = p.Kind == ParameterKind.Dictionary;
ParameterTypes = new IPythonType[0];
}
public AstPythonType(PythonAst ast, IPythonModule declModule, ClassDefinition def, string doc, LocationInfo loc) {
_members = new Dictionary<string, IMember>();
Name = def.Name;
Documentation = doc;
DeclaringModule = declModule;
Mro = new IPythonType[0];
Locations = new[] { loc };
}
public OverviewWalker(ProjectEntry entry, AnalysisUnit topAnalysis, PythonAst tree) {
_entry = entry;
_curUnit = topAnalysis;
_tree = tree;
Debug.Assert(_tree != null);
_scope = topAnalysis.Scope;
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
format.ReflowComment(res, this.GetProceedingWhiteSpace(ast));
res.Append('`');
_expression.AppendCodeString(res, ast, format);
if (!this.IsMissingCloseGrouping(ast)) {
res.Append(this.GetSecondWhiteSpace(ast));
res.Append('`');
}
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
_target.AppendCodeString(res, ast, format);
res.Append(this.GetProceedingWhiteSpaceDefaultNull(ast));
res.Append('.');
if (!this.IsIncompleteNode(ast)) {
res.Append(this.GetSecondWhiteSpaceDefaultNull(ast));
res.Append(this.GetVerbatimImage(ast) ?? _name);
}
}
/// <summary>
/// Removes the import at the specified index (which must be in the range of
/// the Names property) and returns a new ImportStatement which is the same
/// as this one minus the imported name. Preserves all round-tripping metadata
/// in the process.
///
/// New in 1.1.
/// </summary>
public ImportStatement RemoveImport(PythonAst ast, int index) {
if (index < 0 || index >= _names.Length) {
throw new ArgumentOutOfRangeException("index");
}
if (ast == null) {
throw new ArgumentNullException("ast");
}
ModuleName[] names = new ModuleName[_names.Length - 1];
NameExpression[] asNames = _asNames == null ? null : new NameExpression[_asNames.Length - 1];
var asNameWhiteSpace = this.GetNamesWhiteSpace(ast);
var itemWhiteSpace = this.GetListWhiteSpace(ast);
List<string> newAsNameWhiteSpace = new List<string>();
List<string> newListWhiteSpace = new List<string>();
int asIndex = 0;
for (int i = 0, write = 0; i < _names.Length; i++) {
bool includingCurrentName = i != index;
// track the white space, this needs to be kept in sync w/ ToCodeString and how the
// parser creates the white space.
if (i > 0 && itemWhiteSpace != null) {
if (includingCurrentName) {
newListWhiteSpace.Add(itemWhiteSpace[i - 1]);
}
}
if (includingCurrentName) {
names[write] = _names[i];
if (_asNames != null) {
asNames[write] = _asNames[i];
}
write++;
}
if (AsNames[i] != null && includingCurrentName) {
if (asNameWhiteSpace != null) {
newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]);
}
if (_asNames[i].Name.Length != 0) {
if (asNameWhiteSpace != null) {
newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]);
}
}
}
}
var res = new ImportStatement(names, asNames, _forceAbsolute);
ast.CopyAttributes(this, res);
ast.SetAttribute(res, NodeAttributes.NamesWhiteSpace, newAsNameWhiteSpace.ToArray());
ast.SetAttribute(res, NodeAttributes.ListWhiteSpace, newListWhiteSpace.ToArray());
return res;
}
internal override void AppendCodeStringStmt(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
format.ReflowComment(res, this.GetProceedingWhiteSpace(ast));
res.Append("assert");
_test.AppendCodeString(res, ast, format);
if (_message != null) {
res.Append(this.GetSecondWhiteSpace(ast));
res.Append(',');
_message.AppendCodeString(res, ast, format);
}
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
res.Append(this.GetProceedingWhiteSpace(ast));
res.Append("for");
_lhs.AppendCodeString(res, ast, format);
if (!this.IsIncompleteNode(ast)) {
res.Append(this.GetSecondWhiteSpace(ast));
res.Append("in");
_list.AppendCodeString(res, ast, format);
}
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
var whitespace = this.GetListWhiteSpace(ast);
for (int i = 0; i < _dotCount; i++) {
if (whitespace != null) {
res.Append(whitespace[i]);
}
res.Append('.');
}
base.AppendCodeString(res, ast, format);
}
internal override void AppendCodeStringStmt(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
format.ReflowComment(res, this.GetProceedingWhiteSpace(ast));
res.Append("while");
_test.AppendCodeString(res, ast, format);
_body.AppendCodeString(res, ast, format);
if (_else != null) {
format.ReflowComment(res, this.GetSecondWhiteSpaceDefaultNull(ast));
res.Append("else");
_else.AppendCodeString(res, ast, format);
}
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
_target.AppendCodeString(res, ast, format);
format.Append(
res,
format.SpaceBeforeCallParen,
" ",
"",
this.GetProceedingWhiteSpaceDefaultNull(ast)
);
res.Append('(');
if (_args.Length == 0) {
if (format.SpaceWithinEmptyCallArgumentList != null && format.SpaceWithinEmptyCallArgumentList.Value) {
res.Append(' ');
}
} else {
var listWhiteSpace = this.GetListWhiteSpace(ast);
for (int i = 0; i < _args.Length; i++) {
if (i > 0) {
if (listWhiteSpace != null) {
res.Append(listWhiteSpace[i - 1]);
}
res.Append(',');
} else if (format.SpaceWithinCallParens != null) {
_args[i].AppendCodeString(res, ast, format, format.SpaceWithinCallParens.Value ? " " : "");
continue;
}
_args[i].AppendCodeString(res, ast, format);
}
if (listWhiteSpace != null && listWhiteSpace.Length == _args.Length) {
// trailing comma
res.Append(listWhiteSpace[listWhiteSpace.Length - 1]);
res.Append(",");
}
}
if (!this.IsMissingCloseGrouping(ast)) {
if (Args.Count != 0 ||
format.SpaceWithinEmptyCallArgumentList == null ||
!String.IsNullOrWhiteSpace(this.GetSecondWhiteSpaceDefaultNull(ast))) {
format.Append(
res,
format.SpaceWithinCallParens,
" ",
"",
this.GetSecondWhiteSpaceDefaultNull(ast)
);
}
res.Append(')');
}
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format) {
format.ReflowComment(res, this.GetProceedingWhiteSpace(ast));
res.Append("await");
if (!this.IsAltForm(ast)) {
_expression.AppendCodeString(res, ast, format);
var itemWhiteSpace = this.GetListWhiteSpace(ast);
if (itemWhiteSpace != null) {
res.Append(",");
res.Append(itemWhiteSpace[0]);
}
}
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format)
{
format.ReflowComment(res, this.GetProceedingWhiteSpaceDefaultNull(ast));
res.Append(this.GetVerbatimImage(ast) ?? _name);
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format)
{
AppendCodeString(res, ast, format, null);
}
public override string GetLeadingWhiteSpace(PythonAst ast)
{
return(_expression.GetLeadingWhiteSpace(ast));
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format)
{
format.ReflowComment(res, this.GetPreceedingWhiteSpace(ast));
res.Append(_op.ToCodeString());
_expression.AppendCodeString(res, ast, format);
}
internal override void AppendCodeStringStmt(StringBuilder res, PythonAst ast, CodeFormattingOptions format)
{
format.ReflowComment(res, this.GetPreceedingWhiteSpace(ast));
res.Append("continue");
}
public override void SetLeadingWhiteSpace(PythonAst ast, string whiteSpace)
{
_left.SetLeadingWhiteSpace(ast, whiteSpace);
}
public override string GetLeadingWhiteSpace(PythonAst ast)
{
return(_left.GetLeadingWhiteSpace(ast));
}
internal abstract void AppendCodeStringStmt(StringBuilder res, PythonAst ast, CodeFormattingOptions format);
internal override sealed void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format)
{
AppendCodeStringStmt(res, ast, format);
}
internal override void AppendCodeStringStmt(StringBuilder res, PythonAst ast, CodeFormattingOptions format)
{
_body.AppendCodeString(res, ast, format);
res.Append(this.GetExtraVerbatimText(ast));
}
internal override void AppendCodeStringStmt(StringBuilder res, PythonAst ast, CodeFormattingOptions format)
{
_expression.AppendCodeString(res, ast, format);
}
/// <summary>
/// Returns the proceeeding whitespace (newlines and comments) that
/// shows up before this node.
///
/// New in 1.1.
/// </summary>
public virtual string GetLeadingWhiteSpace(PythonAst ast)
{
return(this.GetProceedingWhiteSpaceDefaultNull(ast) ?? "");
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format)
{
_test.AppendCodeString(res, ast, format);
_body.AppendCodeString(res, ast, format);
}
internal override void AppendCodeStringStmt(StringBuilder res, PythonAst ast, CodeFormattingOptions format)
{
if (Decorators != null)
{
Decorators.AppendCodeString(res, ast, format);
}
format.ReflowComment(res, this.GetPreceedingWhiteSpace(ast));
res.Append("class");
res.Append(this.GetSecondWhiteSpace(ast));
res.Append(this.GetVerbatimImage(ast) ?? Name);
if (!this.IsAltForm(ast))
{
format.Append(
res,
format.SpaceBeforeClassDeclarationParen,
" ",
"",
this.GetThirdWhiteSpace(ast)
);
res.Append('(');
}
if (Bases.Count != 0)
{
ListExpression.AppendItems(
res,
ast,
format,
"",
"",
this,
this.Bases.Count,
(i, sb) => {
if (format.SpaceWithinClassDeclarationParens != null && i == 0)
{
// need to remove any leading whitespace which was preserved for
// the 1st param, and then force the correct whitespace.
Bases[i].AppendCodeString(sb, ast, format, format.SpaceWithinClassDeclarationParens.Value ? " " : "");
}
else
{
Bases[i].AppendCodeString(sb, ast, format);
}
}
);
}
else if (!this.IsAltForm(ast))
{
if (format.SpaceWithinEmptyBaseClassList != null && format.SpaceWithinEmptyBaseClassList.Value)
{
res.Append(' ');
}
}
if (!this.IsAltForm(ast) && !this.IsMissingCloseGrouping(ast))
{
if (Bases.Count != 0 ||
format.SpaceWithinEmptyBaseClassList == null ||
!String.IsNullOrWhiteSpace(this.GetFourthWhiteSpace(ast)))
{
format.Append(
res,
format.SpaceWithinClassDeclarationParens,
" ",
"",
this.GetFourthWhiteSpace(ast)
);
}
res.Append(')');
}
_body.AppendCodeString(res, ast, format);
}
public SourceLocation GetHeader(PythonAst ast)
{
return(ast.IndexToLocation(_headerIndex));
}
/// <summary>
/// Removes the import at the specified index (which must be in the range of
/// the Names property) and returns a new ImportStatement which is the same
/// as this one minus the imported name. Preserves all round-tripping metadata
/// in the process.
///
/// New in 1.1.
/// </summary>
public ImportStatement RemoveImport(PythonAst ast, int index)
{
if (index < 0 || index >= _names.Length)
{
throw new ArgumentOutOfRangeException("index");
}
if (ast == null)
{
throw new ArgumentNullException("ast");
}
ModuleName[] names = new ModuleName[_names.Length - 1];
NameExpression[] asNames = _asNames == null ? null : new NameExpression[_asNames.Length - 1];
var asNameWhiteSpace = this.GetNamesWhiteSpace(ast);
var itemWhiteSpace = this.GetListWhiteSpace(ast);
List <string> newAsNameWhiteSpace = new List <string>();
List <string> newListWhiteSpace = new List <string>();
int asIndex = 0;
for (int i = 0, write = 0; i < _names.Length; i++)
{
bool includingCurrentName = i != index;
// track the white space, this needs to be kept in sync w/ ToCodeString and how the
// parser creates the white space.
if (i > 0 && itemWhiteSpace != null)
{
if (includingCurrentName)
{
newListWhiteSpace.Add(itemWhiteSpace[i - 1]);
}
}
if (includingCurrentName)
{
names[write] = _names[i];
if (_asNames != null)
{
asNames[write] = _asNames[i];
}
write++;
}
if (AsNames[i] != null && includingCurrentName)
{
if (asNameWhiteSpace != null)
{
newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]);
}
if (_asNames[i].Name.Length != 0)
{
if (asNameWhiteSpace != null)
{
newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]);
}
}
}
}
var res = new ImportStatement(names, asNames, _forceAbsolute);
ast.CopyAttributes(this, res);
ast.SetAttribute(res, NodeAttributes.NamesWhiteSpace, newAsNameWhiteSpace.ToArray());
ast.SetAttribute(res, NodeAttributes.ListWhiteSpace, newListWhiteSpace.ToArray());
return(res);
}
internal override void AppendCodeStringStmt(StringBuilder res, PythonAst ast, CodeFormattingOptions format)
{
// SuiteStatement comes in 3 forms:
// 1. The body of a if/else/while/for/etc... where there's an opening colon
// 2. A set of semi-colon separated items
// 3. A top-level group of statements in a top-level PythonAst node.
var itemWhiteSpace = this.GetListWhiteSpace(ast);
var colonWhiteSpace = this.GetPreceedingWhiteSpaceDefaultNull(ast);
if (this.IsAltForm(ast))
{
// suite statement in top-level PythonAst, we have no colons or other delimiters
foreach (var statement in _statements)
{
statement.AppendCodeString(res, ast, format);
}
}
else if (itemWhiteSpace != null)
{
if (format.BreakMultipleStatementsPerLine)
{
string leadingWhiteSpace = "";
for (int i = 0; i < _statements.Length; i++)
{
if (i == 0)
{
StringBuilder tmp = new StringBuilder();
_statements[i].AppendCodeString(tmp, ast, format);
var stmt = tmp.ToString();
res.Append(stmt);
// figure out the whitespace needed for the next statement based upon the current statement
for (int curChar = 0; curChar < stmt.Length; curChar++)
{
if (!char.IsWhiteSpace(stmt[curChar]))
{
leadingWhiteSpace = format.GetNextLineProceedingText(stmt.Substring(0, curChar));
break;
}
}
}
else
{
_statements[i].AppendCodeString(res, ast, format, leadingWhiteSpace);
}
}
}
else
{
// form 2, semi-colon seperated list.
for (int i = 0; i < _statements.Length; i++)
{
if (i > 0)
{
if (i - 1 < itemWhiteSpace.Length)
{
res.Append(itemWhiteSpace[i - 1]);
}
res.Append(';');
}
_statements[i].AppendCodeString(res, ast, format);
}
}
if (itemWhiteSpace != null && itemWhiteSpace.Length == _statements.Length && _statements.Length != 0)
{
// trailing semi-colon
if (!format.RemoveTrailingSemicolons)
{
res.Append(itemWhiteSpace[itemWhiteSpace.Length - 1]);
res.Append(";");
}
}
}
else
{
// 3rd form, suite statement as the body of a class/function, we include the colon.
if (colonWhiteSpace != null)
{
res.Append(colonWhiteSpace);
}
res.Append(':');
foreach (var statement in _statements)
{
statement.AppendCodeString(res, ast, format);
}
}
}
/// <summary>
/// Marks this tuple expression as having no parenthesis for the purposes of round tripping.
/// </summary>
public void RoundTripHasNoParenthesis(PythonAst ast)
{
ast.SetAttribute(this, NodeAttributes.IsAltFormValue, NodeAttributes.IsAltFormValue);
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format)
{
// WithStatement expands us
throw new InvalidOperationException();
}
public void AddPreceedingWhiteSpace(PythonAst ast, string whiteSpace)
{
ast.SetAttribute(this, NodeAttributes.PreceedingWhiteSpace, whiteSpace);
}
public void RoundTripRemoveValueWhiteSpace(PythonAst ast)
{
ast.SetAttribute(this, NodeAttributes.IsAltFormValue, NodeAttributes.IsAltFormValue);
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format, string leadingWhiteSpace)
{
string kwOnlyText = this.GetExtraVerbatimText(ast);
if (kwOnlyText != null)
{
if (leadingWhiteSpace != null)
{
res.Append(leadingWhiteSpace);
res.Append(kwOnlyText.TrimStart());
leadingWhiteSpace = null;
}
else
{
res.Append(kwOnlyText);
}
}
switch (Kind)
{
case ParameterKind.Dictionary:
res.Append(leadingWhiteSpace ?? this.GetPreceedingWhiteSpace(ast));
res.Append("**");
res.Append(this.GetSecondWhiteSpace(ast));
res.Append(this.GetVerbatimImage(ast) ?? _name);
AppendAnnotation(res, ast, format);
break;
case ParameterKind.List:
res.Append(leadingWhiteSpace ?? this.GetPreceedingWhiteSpace(ast));
res.Append('*');
res.Append(this.GetSecondWhiteSpace(ast));
res.Append(this.GetVerbatimImage(ast) ?? _name);
AppendAnnotation(res, ast, format);
break;
case ParameterKind.Normal:
if (this.IsAltForm(ast))
{
res.Append(leadingWhiteSpace ?? this.GetPreceedingWhiteSpace(ast));
res.Append('(');
res.Append(this.GetThirdWhiteSpace(ast));
res.Append(this.GetVerbatimImage(ast) ?? _name);
if (!this.IsMissingCloseGrouping(ast))
{
res.Append(this.GetSecondWhiteSpace(ast));
res.Append(')');
}
}
else
{
res.Append(leadingWhiteSpace ?? this.GetPreceedingWhiteSpaceDefaultNull(ast));
res.Append(this.GetVerbatimImage(ast) ?? _name);
AppendAnnotation(res, ast, format);
}
break;
case ParameterKind.KeywordOnly:
res.Append(leadingWhiteSpace ?? this.GetPreceedingWhiteSpace(ast));
res.Append(this.GetVerbatimImage(ast) ?? _name);
AppendAnnotation(res, ast, format);
break;
default: throw new InvalidOperationException();
}
if (_defaultValue != null)
{
format.Append(
res,
format.SpaceAroundDefaultValueEquals,
" ",
"",
NodeAttributes.GetWhiteSpace(this, ast, WhitespacePrecedingAssign)
);
res.Append('=');
if (format.SpaceAroundDefaultValueEquals != null)
{
_defaultValue.AppendCodeString(res, ast, format, format.SpaceAroundDefaultValueEquals.Value ? " " : "");
}
else
{
_defaultValue.AppendCodeString(res, ast, format);
}
}
}
public PythonReference[] GetReferences(PythonAst ast)
{
return(GetVariableReferences(this, ast));
}
internal override void AppendCodeString(StringBuilder res, PythonAst ast, CodeFormattingOptions format)
{
res.Append(this.GetProceedingWhiteSpace(ast));
res.Append('*');
_expr.AppendCodeString(res, ast, format);
}
public SourceSpan GetSpan(PythonAst parent)
{
return(new SourceSpan(GetStart(parent), GetEnd(parent)));
}
public override void SetLeadingWhiteSpace(PythonAst ast, string whiteSpace)
{
_expression.SetLeadingWhiteSpace(ast, whiteSpace);
}
/// <summary>
/// Gets the variable reference for the specific assignment to the variable for this function definition.
/// </summary>
public PythonReference GetVariableReference(PythonAst ast)
{
return(GetVariableReference(this, ast));
}
public static void CopyLeadingWhiteSpace(PythonAst parentNode, Node fromNode, Node toNode)
{
parentNode.SetAttribute(toNode, NodeAttributes.PreceedingWhiteSpace, fromNode.GetLeadingWhiteSpace(parentNode));
}
internal override void AppendCodeStringStmt(StringBuilder res, PythonAst ast, CodeFormattingOptions format)
{
var decorateWhiteSpace = this.GetNamesWhiteSpace(ast);
if (Decorators != null)
{
Decorators.AppendCodeString(res, ast, format);
}
format.ReflowComment(res, this.GetProceedingWhiteSpaceDefaultNull(ast));
res.Append("def");
var name = this.GetVerbatimImage(ast) ?? Name;
if (!String.IsNullOrEmpty(name))
{
res.Append(this.GetSecondWhiteSpace(ast));
res.Append(name);
if (!this.IsIncompleteNode(ast))
{
format.Append(
res,
format.SpaceBeforeFunctionDeclarationParen,
" ",
"",
this.GetThirdWhiteSpaceDefaultNull(ast)
);
res.Append('(');
if (Parameters.Count != 0)
{
var commaWhiteSpace = this.GetListWhiteSpace(ast);
ParamsToString(res,
ast,
commaWhiteSpace,
format,
format.SpaceWithinFunctionDeclarationParens != null ?
format.SpaceWithinFunctionDeclarationParens.Value ? " " : "" :
null
);
}
string namedOnly = this.GetExtraVerbatimText(ast);
if (namedOnly != null)
{
res.Append(namedOnly);
}
if (!this.IsMissingCloseGrouping(ast))
{
format.Append(
res,
Parameters.Count != 0 ?
format.SpaceWithinFunctionDeclarationParens :
format.SpaceWithinEmptyParameterList,
" ",
"",
this.GetFourthWhiteSpaceDefaultNull(ast)
);
res.Append(')');
}
if (ReturnAnnotation != null)
{
format.Append(
res,
format.SpaceAroundAnnotationArrow,
" ",
"",
this.GetFifthWhiteSpace(ast)
);
res.Append("->");
_returnAnnotation.AppendCodeString(
res,
ast,
format,
format.SpaceAroundAnnotationArrow != null ?
format.SpaceAroundAnnotationArrow.Value ? " " : "" :
null
);
}
if (Body != null)
{
Body.AppendCodeString(res, ast, format);
}
}
}
}
public SourceLocation GetEnd(PythonAst parent)
{
return(parent.IndexToLocation(EndIndex));
}