public FunctionDefinition(NameExpression name, Parameter[] parameters)
: this(name, parameters, (Statement)null)
{
}
private static bool IsNotIgnoredName(NameExpression name) => IsNotIgnoredName(name.Name);
public override void PostWalk(NameExpression node)
{
}
public ClassDefinition(NameExpression /*!*/ name, ImmutableArray <Arg> bases, Statement body)
{
_name = name;
Bases = bases;
_body = body;
}
public virtual void PostWalk(NameExpression node)
{
}
// NameExpression
public override bool Walk(NameExpression node)
{
return(false);
}
// NameExpression
public override bool Walk(NameExpression node)
{
return(Location >= node.StartIndex && Location <= node.EndIndex);
}
// NameExpression
public virtual bool Walk(NameExpression node)
{
return(true);
}
public override bool Walk(NameExpression node)
{
_binder.DefineDeleted(node.Name);
return(false);
}
public override bool Walk(NameExpression node)
{
node.AddVariableReference(GlobalScope, BindReferences, Reference(node.Name));
return(true);
}
public ClassDefinition(NameExpression /*!*/ name, Arg[] bases, Statement body)
{
_name = name;
_bases = bases;
_body = body;
}
internal virtual void AppendParameterName(StringBuilder res, PythonAst ast, CodeFormattingOptions format, string leadingWhiteSpace) => NameExpression?.AppendCodeString(res, ast, format, leadingWhiteSpace);
public Parameter(NameExpression name, ParameterKind kind)
{
NameExpression = name;
Kind = kind;
}
/// <summary>
/// Returns a new FromImport statement that is identical to this one but has
/// removed the specified import statement. Otherwise preserves any attributes
/// for the statement.
///
/// New in 1.1.
/// <param name="ast">The parent AST whose attributes should be updated for the new node.</param>
/// <param name="index">The index in Names of the import to be removed.</param>
/// </summary>
public FromImportStatement RemoveImport(PythonAst ast, int index)
{
if (index < 0 || index >= Names.Count)
{
throw new ArgumentOutOfRangeException("index");
}
if (ast == null)
{
throw new ArgumentNullException("ast");
}
var names = new NameExpression[Names.Count - 1];
var asNames = AsNames == null ? null : new NameExpression[AsNames.Count - 1];
var asNameWhiteSpace = this.GetNamesWhiteSpace(ast);
var newAsNameWhiteSpace = new List <string>();
var importIndex = ImportIndex;
var asIndex = 0;
for (int i = 0, write = 0; i < Names.Count; i++)
{
var 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 (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length)
{
if (write > 0)
{
if (includingCurrentName)
{
newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]);
}
else
{
asIndex++;
}
}
else if (i > 0)
{
asIndex++;
}
}
if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length)
{
if (includingCurrentName)
{
if (newAsNameWhiteSpace.Count == 0)
{
// no matter what we want the 1st entry to have the whitespace after the import keyword
newAsNameWhiteSpace.Add(asNameWhiteSpace[0]);
asIndex++;
}
else
{
newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]);
}
}
else
{
asIndex++;
}
}
if (includingCurrentName)
{
names[write] = Names[i];
if (AsNames != null)
{
asNames[write] = AsNames[i];
}
write++;
}
if (AsNames != null && AsNames[i] != null)
{
if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length)
{
if (i != index)
{
newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]);
}
else
{
asIndex++;
}
}
if (AsNames[i].Name.Length != 0)
{
if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length)
{
if (i != index)
{
newAsNameWhiteSpace.Add(asNameWhiteSpace[asIndex++]);
}
else
{
asIndex++;
}
}
}
else
{
asIndex++;
}
}
}
if (asNameWhiteSpace != null && asIndex < asNameWhiteSpace.Length)
{
// trailing comma
newAsNameWhiteSpace.Add(asNameWhiteSpace[asNameWhiteSpace.Length - 1]);
}
var res = new FromImportStatement(Root, names, asNames, IsFromFuture, ForceAbsolute, importIndex);
ast.CopyAttributes(this, res);
ast.SetAttribute(res, NodeAttributes.NamesWhiteSpace, newAsNameWhiteSpace.ToArray());
return(res);
}
internal void AddNonLocalVariable(NameExpression name)
{
_nonLocalVars = _nonLocalVars ?? new List <NameExpression>();
_nonLocalVars.Add(name);
}
