/// <summary> /// Returns a new SuiteStatement which is composed of a subset of the statements in this suite statement. /// </summary> /// <param name="start"></param> /// <param name="end"></param> /// <returns></returns> public SuiteStatement CloneSubset(JAst ast, int start, int end) { Statement[] statements = new Statement[end - start + 1]; for (int i = start; i <= end; i++) { statements[i - start] = Statements[i]; } var res = new SuiteStatement(statements); // propagate white space so we stay mostly the same... var itemWhiteSpace = this.GetListWhiteSpace(ast); var colonWhiteSpace = this.GetProceedingWhiteSpaceDefaultNull(ast); if (colonWhiteSpace != null) { ast.SetAttribute(res, NodeAttributes.PreceedingWhiteSpace, ""); } else if (itemWhiteSpace != null) { // semi-colon list of statements, must end in a new line, but the original new line // could be multiple lines. ast.SetAttribute(res, NodeAttributes.ListWhiteSpace, new string[0]); var trailingNewLine = this.GetTrailingNewLine(ast); if (trailingNewLine != null) { ast.SetAttribute(res, NodeAttributes.TrailingNewLine, "\r\n"); } } if (this.IsAltForm(ast)) { ast.SetAttribute(res, NodeAttributes.IsAltFormValue, NodeAttributes.IsAltFormValue); } return res; }
/// <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(JAst ast, int index) { if (index < 0 || index >= _names.Length) { throw new ArgumentOutOfRangeException("index"); } if (ast == null) { throw new ArgumentNullException("ast"); } NameExpression[] names = new NameExpression[_names.Length - 1]; NameExpression[] asNames = _asNames == null ? null : new NameExpression[_asNames.Length - 1]; var asNameWhiteSpace = this.GetNamesWhiteSpace(ast); List<string> newAsNameWhiteSpace = 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 (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); ast.CopyAttributes(this, res); ast.SetAttribute(res, NodeAttributes.NamesWhiteSpace, newAsNameWhiteSpace.ToArray()); return res; }
public static void CopyTrailingNewLine(JAst parentNode, Node fromNode, Node toNode) { parentNode.SetAttribute(toNode, NodeAttributes.TrailingNewLine, fromNode.GetTrailingNewLine(parentNode)); }
public static void CopyLeadingWhiteSpace(JAst parentNode, Node fromNode, Node toNode) { parentNode.SetAttribute(toNode, NodeAttributes.PreceedingWhiteSpace, fromNode.GetLeadingWhiteSpace(parentNode)); }
/// <summary> /// Marks this tuple expression as having no parenthesis for the purposes of round tripping. /// </summary> public void RoundTripHasNoParenthesis(JAst ast) { ast.SetAttribute(this, NodeAttributes.IsAltFormValue, NodeAttributes.IsAltFormValue); }
private JAst CreateAst(Statement ret) { var ast = new JAst(ret, _tokenizer.GetLineLocations()); ast.PrivatePrefix = _privatePrefix; if (_token.Token != null) { ast.SetLoc(0, GetEnd()); } if (_verbatim) { AddExtraVerbatimText(ast, _lookaheadWhiteSpace); } foreach (var keyValue in _attributes) { foreach (var nodeAttr in keyValue.Value) { ast.SetAttribute(keyValue.Key, nodeAttr.Key, nodeAttr.Value); } } JNameBinder.BindAst(_langVersion, ast, _errors, _bindReferences); return ast; }
public void AddPreceedingWhiteSpace(JAst ast, string whiteSpace) { ast.SetAttribute(this, NodeAttributes.PreceedingWhiteSpace, whiteSpace); }
public static void AddVariableReference(this Node node, JAst ast, bool bindNames, object reference) { if (bindNames) { ast.SetAttribute(node, VariableReference, reference); } }
public static void AddVariable(this Parameter node, JAst ast, bool bindNames, JVariable variable) { if (bindNames) { ast.SetAttribute(node, Variable, variable); } }
public void RoundTripRemoveValueWhiteSpace(JAst ast) { ast.SetAttribute(this, NodeAttributes.IsAltFormValue, NodeAttributes.IsAltFormValue); }
/// <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(JAst 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; }