public async Task<IEnumerable<CodeAction>> GetRefactoringsAsync(Document document, TextSpan textSpan, CancellationToken cancellationToken)
		{
			var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
			var node = root.FindNode(textSpan);
			var switchStatementNode = node as SwitchStatementSyntax;
			if (switchStatementNode == null)
				return null;

			var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

			var memberEx = switchStatementNode.Expression as MemberAccessExpressionSyntax;
			if (memberEx == null)
				return null;

			var symbolInfo = semanticModel.GetTypeInfo(memberEx.Name);
			var enumTypeInfo = symbolInfo.Type;
			if (enumTypeInfo.TypeKind != TypeKind.Enum)
				return null;

			var enumName = enumTypeInfo.Name;
			var nameSpace = enumTypeInfo.ContainingNamespace.Name;
			var enumType = Type.GetType(nameSpace + "." + enumName);
			if (enumType == null)
				return null;

			return new[] { CodeAction.Create("Explode Switch", c => ExplodeSwitch(document, root, semanticModel, switchStatementNode, c)) };
		}
 public PathSyntaxReference(SyntaxNode node)
 {
     _tree = node.SyntaxTree;
     _kind = node.Kind();
     _textSpan = node.Span;
     _pathFromRoot = ComputePathFromRoot(node);
 }
Ejemplo n.º 3
0
 public OutliningSpan(TextSpan textSpan, TextSpan hintSpan, string bannerText, bool autoCollapse)
 {
     this.TextSpan = textSpan;
     this.BannerText = bannerText;
     this.HintSpan = hintSpan;
     this.AutoCollapse = autoCollapse;
 }
Ejemplo n.º 4
0
 public static bool OverlapsHiddenPosition(
     this SourceText text, TextSpan span, Func<int, CancellationToken, bool> isPositionHidden, CancellationToken cancellationToken)
 {
     var result = TryOverlapsHiddenPosition(text, span, isPositionHidden, cancellationToken);
     cancellationToken.ThrowIfCancellationRequested();
     return result;
 }
Ejemplo n.º 5
0
        public TokenStream(TreeData treeData, OptionSet optionSet, TextSpan spanToFormat, AbstractTriviaDataFactory factory)
        {
            using (Logger.LogBlock(FunctionId.Formatting_TokenStreamConstruction, CancellationToken.None))
            {
                // initialize basic info
                _factory = factory;
                _treeData = treeData;
                _optionSet = optionSet;

                // use some heuristics to get initial size of list rather than blindly start from default size == 4
                int sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;
                _tokens = new List<SyntaxToken>(sizeOfList);
                _tokens.AddRange(_treeData.GetApplicableTokens(spanToFormat));

                Contract.Requires(this.TokenCount > 0);

                // initialize trivia related info
                _cachedOriginalTriviaInfo = new TriviaData[this.TokenCount - 1];

                _tokenToIndexMap = new Dictionary<SyntaxToken, int>(this.TokenCount);
                for (int i = 0; i < this.TokenCount; i++)
                {
                    _tokenToIndexMap.Add(_tokens[i], i);
                }

                // Func Cache
                _getTriviaData = this.GetTriviaData;
                _getOriginalTriviaData = this.GetOriginalTriviaData;
            }

            DebugCheckTokenOrder();
        }
        public override SignatureHelpState GetCurrentArgumentState(SyntaxNode root, int position, ISyntaxFactsService syntaxFacts, TextSpan currentSpan, CancellationToken cancellationToken)
        {
            if (GetOuterMostTupleExpressionInSpan(root, position, syntaxFacts, currentSpan, cancellationToken, out var expression))
            {
                return CommonSignatureHelpUtilities.GetSignatureHelpState(expression, position,
                   getOpenToken: s_getOpenToken,
                   getCloseToken: s_getCloseToken,
                   getArgumentsWithSeparators: s_getArgumentsWithSeparators,
                   getArgumentNames: s_getArgumentNames);
            }

            if (GetOuterMostParenthesizedExpressionInSpan(root, position, syntaxFacts, currentSpan, cancellationToken, out var parenthesizedExpression))
            {
                if (currentSpan.Start == parenthesizedExpression.SpanStart)
                {
                    return new SignatureHelpState(
                        argumentIndex: 0,
                        argumentCount: 0,
                        argumentName: string.Empty,
                        argumentNames: null);
                }
            }

            return null;
        }
Ejemplo n.º 7
0
        public FileSystemCompletionHelper(
            CompletionListProvider completionProvider,
            TextSpan textChangeSpan,
            ICurrentWorkingDirectoryDiscoveryService fileSystemDiscoveryService,
            Glyph folderGlyph,
            Glyph fileGlyph,
            ImmutableArray<string> searchPaths,
            IEnumerable<string> allowableExtensions,
            Func<string, bool> exclude = null,
            CompletionItemRules itemRules = null)
        {
            Debug.Assert(searchPaths.All(path => PathUtilities.IsAbsolute(path)));

            _completionProvider = completionProvider;
            _textChangeSpan = textChangeSpan;
            _searchPaths = searchPaths;
            _allowableExtensions = allowableExtensions.Select(e => e.ToLowerInvariant()).ToSet();
            _fileSystemDiscoveryService = fileSystemDiscoveryService;
            _folderGlyph = folderGlyph;
            _fileGlyph = fileGlyph;
            _exclude = exclude;
            _itemRules = itemRules;

            _lazyGetDrives = new Lazy<string[]>(() =>
                IOUtilities.PerformIO(Directory.GetLogicalDrives, SpecializedCollections.EmptyArray<string>()));
        }
Ejemplo n.º 8
0
 private void AddClassification(TextSpan span, string type)
 {
     if (ShouldAddSpan(span))
     {
         _result.Add(new ClassifiedSpan(type, span));
     }
 }
        public async Task<IEnumerable<EncapsulateFieldCodeAction>> GetEncapsulateFieldCodeActionsAsync(Document document, TextSpan span, CancellationToken cancellationToken)
        {
            var fields = (await GetFieldsAsync(document, span, cancellationToken).ConfigureAwait(false)).ToImmutableArrayOrEmpty();
            if (fields.Length == 0)
            {
                return SpecializedCollections.EmptyEnumerable<EncapsulateFieldCodeAction>();
            }

            if (fields.Length == 1)
            {
                // there is only one field
                return EncapsulateOneField(document, span, fields[0], index: 0);
            }
            else
            {
                // there are multiple fields.
                var current = SpecializedCollections.EmptyEnumerable<EncapsulateFieldCodeAction>();

                if (span.IsEmpty)
                {
                    // if there is no selection, get action for each field + all of them.
                    for (var i = 0; i < fields.Length; i++)
                    {
                        current = current.Concat(EncapsulateOneField(document, span, fields[i], i));
                    }
                }

                return current.Concat(EncapsulateAllFields(document, span));
            }
        }
Ejemplo n.º 10
0
 public static CompletionItem Create(
     string displayText,
     TextSpan span,
     ISymbol symbol,
     int contextPosition = -1,
     int descriptionPosition = -1,
     string sortText = null,
     string insertionText = null,
     Glyph? glyph = null,
     string filterText = null,
     bool preselect = false,
     SupportedPlatformData supportedPlatforms = null,
     bool isArgumentName = false,
     ImmutableDictionary<string, string> properties = null,
     CompletionItemRules rules = null)
 {
     return Create(
         displayText: displayText,
         span: span,
         symbols: ImmutableArray.Create(symbol),
         contextPosition: contextPosition,
         descriptionPosition: descriptionPosition,
         sortText: sortText,
         insertionText: insertionText,
         glyph: glyph,
         filterText: filterText,
         preselect: preselect,
         supportedPlatforms: supportedPlatforms,
         isArgumentName: isArgumentName,
         properties: properties,
         rules: rules);
 }
Ejemplo n.º 11
0
        /// <summary>
        /// Changes the indentation of the current line based on the last
        /// bit of code typed.
        /// </summary>
        /// <param name="changedArea">Area of changed code</param>
        public void ChangeIndentation(TextSpan changedArea)
        {
            TextSpan area = changedArea;
            string text = source.GetText(area);
            string line = source.GetLineUptoPosition(area.iStartLine, area.iStartIndex);

            if (!line.EndsWith(text))
            {
                // if commit includes last bit of text typed, the line won't have it yet
                // so stick it on for our parsing sanity
                // ** probably not the best thing to be doing here, but we can't just
                // get the whole line, because we may be pressing return in the centre
                // of it
                line += text;
            }

            if (RequiresIndent(line))
            {
                source.SetText(area, text + Indent);    // add an indent to the end of the changed text
                MoveCaret(Indent.Length);               // move the caret to the new end of line
            }
            else if (RequiresDedent(line))
            {
                source.SetText(area, text.Remove(text.Length - Indent.Length)); // remove an indent
                MoveCaret(-Indent.Length);                                      // move caret in a bit
            }
        }
Ejemplo n.º 12
0
        public static bool CheckIfSpanWithinSequencePoints(TextSpan span, string source, string pdb)
        {
            // calculate row and column from span
            var text = SourceText.From(source);
            var startLine = text.Lines.GetLineFromPosition(span.Start);
            var startRow = startLine.LineNumber + 1;
            var startColumn = span.Start - startLine.Start + 1;

            var endLine = text.Lines.GetLineFromPosition(span.End);
            var endRow = endLine.LineNumber + 1;
            var endColumn = span.End - endLine.Start + 1;

            var doc = new XmlDocument();
            doc.LoadXml(pdb);

            foreach (XmlNode entry in doc.GetElementsByTagName("sequencePoints"))
            {
                foreach (XmlElement item in entry.ChildNodes)
                {
                    if (startRow.ToString() == item.GetAttribute("startLine") &&
                        startColumn.ToString() == item.GetAttribute("startColumn") &&
                        endRow.ToString() == item.GetAttribute("endLine") &&
                        endColumn.ToString() == item.GetAttribute("endColumn"))
                    {
                        return true;
                    }
                }
            }

            return false;
        }
 protected CommonLibraryNode(CommonLibraryNode node) :
     base(node) {
     _fileId = node._fileId;
     _ownerHierarchy = node._ownerHierarchy;
     _fileMoniker = node._fileMoniker;
     _sourceSpan = node._sourceSpan;
 }
Ejemplo n.º 14
0
 public ConflictLocationInfo(RelatedLocation location)
 {
     Debug.Assert(location.ComplexifiedTargetSpan.Contains(location.ConflictCheckSpan) || location.Type == RelatedLocationType.UnresolvableConflict);
     this.ComplexifiedSpan = location.ComplexifiedTargetSpan;
     this.DocumentId = location.DocumentId;
     this.OriginalIdentifierSpan = location.ConflictCheckSpan;
 }
        public void GetAdjustedDiagnosticSpan(
            DocumentId documentId, Location location,
            out TextSpan sourceSpan, out FileLinePositionSpan originalLineInfo, out FileLinePositionSpan mappedLineInfo)
        {
            sourceSpan = location.SourceSpan;
            originalLineInfo = location.GetLineSpan();
            mappedLineInfo = location.GetMappedLineSpan();

            // check quick bail out case.
            if (location == Location.None)
            {
                return;
            }
            // Update the original source span, if required.
            if (!TryAdjustSpanIfNeededForVenus(documentId, originalLineInfo, mappedLineInfo, out var originalSpan, out var mappedSpan))
            {
                return;
            }

            if (originalSpan.Start != originalLineInfo.StartLinePosition || originalSpan.End != originalLineInfo.EndLinePosition)
            {
                originalLineInfo = new FileLinePositionSpan(originalLineInfo.Path, originalSpan.Start, originalSpan.End);

                var textLines = location.SourceTree.GetText().Lines;
                var startPos = textLines.GetPosition(originalSpan.Start);
                var endPos = textLines.GetPosition(originalSpan.End);

                sourceSpan = TextSpan.FromBounds(startPos, Math.Max(startPos, endPos));
            }

            if (mappedSpan.Start != mappedLineInfo.StartLinePosition || mappedSpan.End != mappedLineInfo.EndLinePosition)
            {
                mappedLineInfo = new FileLinePositionSpan(mappedLineInfo.Path, mappedSpan.Start, mappedSpan.End);
            }
        }
        protected static SyntaxNode RecoverNode(SyntaxTree tree, TextSpan textSpan, int kind)
        {
            var token = tree.GetRoot().FindToken(textSpan.Start, findInsideTrivia: true);
            var node = token.Parent;

            while (node != null)
            {
                if (node.Span == textSpan && node.RawKind == kind)
                {
                    return node;
                }

                var structuredTrivia = node as IStructuredTriviaSyntax;
                if (structuredTrivia != null)
                {
                    node = structuredTrivia.ParentTrivia.Token.Parent;
                }
                else
                {
                    node = node.Parent;
                }
            }

            throw Contract.Unreachable;
        }
 public PathSyntaxReference(SyntaxNode node)
 {
     this.tree = node.SyntaxTree;
     this.kind = node.CSharpKind();
     this.textSpan = node.Span;
     this.pathFromRoot = ComputePathFromRoot(node);
 }
Ejemplo n.º 18
0
        internal static StatementRange GetStatementRange(string fileName, int startLine, int startColumn)
        {
            try
            {
                logger.Trace("Line: {0} Column: {1} Source: {2}", startLine, startColumn, fileName);

                SyntaxTree syntaxTree = CSharpSyntaxTree.ParseFile(fileName);
                SourceText text = syntaxTree.GetText();
                var root = (CompilationUnitSyntax) syntaxTree.GetRoot();

                var span = new TextSpan(text.Lines[startLine - 1].Start + startColumn, 1);
                SyntaxNode node = root.FindNode(span, false, false);

                if (node is BlockSyntax)
                    return MapBlockSyntax(span, node);
                while (node is TypeSyntax || node is MemberAccessExpressionSyntax)
                    node = node.Parent;

                Location location = node.GetLocation();
                FileLinePositionSpan mapped = location.GetMappedLineSpan();

                return new StatementRange
                {
                    StartLine = mapped.StartLinePosition.Line,
                    StartColumn = mapped.StartLinePosition.Character,
                    EndLine = mapped.EndLinePosition.Line,
                    EndColumn = mapped.EndLinePosition.Character,
                };
            }
            catch
            {
                return null;
            }
        }
 public void Ctor2()
 {
     var span = new TextSpan(1, 40);
     Assert.Equal(1, span.Start);
     Assert.Equal(40, span.Length);
     Assert.Equal(41, span.End);
 }
Ejemplo n.º 20
0
 public SignatureHelpModel(TextSpan applicableSpan, IEnumerable<SignatureItem> signatures, SignatureItem signature, int selectedParameter)
 {
     Signatures = signatures.ToImmutableArray();
     ApplicableSpan = applicableSpan;
     Signature = signature;
     SelectedParameter = selectedParameter;
 }
 public static IEnumerable<Diagnostic> GetDocumentDiagnostics(DiagnosticAnalyzer workspaceAnalyzerOpt, Document document, TextSpan span, Action<Exception, DiagnosticAnalyzer, Diagnostic> onAnalyzerException = null, bool logAnalyzerExceptionAsDiagnostics = false)
 {
     using (var testDriver = new TestDiagnosticAnalyzerDriver(document.Project, workspaceAnalyzerOpt, onAnalyzerException, logAnalyzerExceptionAsDiagnostics))
     {
         return testDriver.GetDocumentDiagnostics(workspaceAnalyzerOpt, document, span);
     }
 }
 public void Ctor1()
 {
     var span = new TextSpan(0, 42);
     Assert.Equal(0, span.Start);
     Assert.Equal(42, span.Length);
     Assert.Equal(42, span.End);
 }
 internal ApiLine(string text, TextSpan span, SourceText sourceText, string path)
 {
     Text = text;
     Span = span;
     SourceText = sourceText;
     Path = path;
 }
        public async Task<ImmutableArray<DocumentHighlights>> GetDocumentHighlightsAsync(
            Document document, int position, IImmutableSet<Document> documentsToSearch, CancellationToken cancellationToken)
        {
            // use speculative semantic model to see whether we are on a symbol we can do HR
            var span = new TextSpan(position, 0);
            var solution = document.Project.Solution;

            var semanticModel = await document.GetSemanticModelForSpanAsync(span, cancellationToken).ConfigureAwait(false);
            var symbol = await SymbolFinder.FindSymbolAtPositionAsync(
                semanticModel, position, solution.Workspace, cancellationToken).ConfigureAwait(false);
            if (symbol == null)
            {
                return ImmutableArray<DocumentHighlights>.Empty;
            }

            symbol = await GetSymbolToSearchAsync(document, position, semanticModel, symbol, cancellationToken).ConfigureAwait(false);
            if (symbol == null)
            {
                return ImmutableArray<DocumentHighlights>.Empty;
            }

            // Get unique tags for referenced symbols
            return await GetTagsForReferencedSymbolAsync(
                new SymbolAndProjectId(symbol, document.Project.Id), documentsToSearch, 
                solution, cancellationToken).ConfigureAwait(false);
        }
Ejemplo n.º 25
0
        public CodeRefactoring GetRefactoring(IDocument document, TextSpan textSpan, CancellationToken cancellationToken)
        {
            var tree = (SyntaxTree)document.GetSyntaxTree(cancellationToken);
            var token = tree.GetRoot().FindToken(textSpan.Start);

            if (token.Parent is ClassDeclarationSyntax || token.Parent is StructDeclarationSyntax) {
                var t = (TypeDeclarationSyntax)token.Parent;
                if (!CanInferNonTrivialConstructor(t)) return null;
                return new CodeRefactoring(new[] { new ReadyCodeAction("Infer Non-Trivial Constructor", document, t, () => {
                    var c = TryInferNonTrivialConstructor(t, document.TryGetSemanticModel());
                    var i = 0;
                    var ms = t.Members.Insert(i, new[] {c}).List();
                    return t.With(members: ms);
                })});
            }

            if (token.Parent is MemberDeclarationSyntax && (token.Parent.Parent is ClassDeclarationSyntax || token.Parent.Parent is StructDeclarationSyntax)) {
                var m = (MemberDeclarationSyntax)token.Parent;
                var t = (TypeDeclarationSyntax)m.Parent;
                if (!CanInferNonTrivialConstructor(t)) return null;
                return new CodeRefactoring(new[] { new ReadyCodeAction("Infer Non-Trivial Constructor Here", document, t, () => {
                    var c = TryInferNonTrivialConstructor(t, document.TryGetSemanticModel());
                    var i = t.Members.IndexOf(m);
                    var ms = t.Members.Insert(i, new[] {c}).List();
                    return t.With(members: ms);
                })});
            }

            return null;
        }
		protected async override Task<IEnumerable<CompletionData>> GetItemsWorkerAsync (CompletionResult completionResult, CompletionEngine engine, CompletionContext completionContext, CompletionTriggerInfo info, SyntaxContext ctx, CancellationToken cancellationToken)
		{
			var position = completionContext.Position;
			var document = completionContext.Document;
			var span = new TextSpan(position, 0);
			var semanticModel = await document.GetCSharpSemanticModelForSpanAsync(span, cancellationToken).ConfigureAwait(false);
			var syntaxTree = semanticModel.SyntaxTree;
			//	var ctx = await completionContext.GetSyntaxContextAsync (engine.Workspace, cancellationToken).ConfigureAwait (false);

			if (syntaxTree.IsInNonUserCode(position, cancellationToken) ||
				syntaxTree.IsPreProcessorDirectiveContext(position, cancellationToken))
			{
				return Enumerable.Empty<CompletionData> ();
			}

			if (!syntaxTree.IsRightOfDotOrArrowOrColonColon(position, cancellationToken))
			{
				return Enumerable.Empty<CompletionData> ();
			}

			var node = syntaxTree.FindTokenOnLeftOfPosition(position, cancellationToken)
				.GetPreviousTokenIfTouchingWord(position)
				.Parent;

			if (node.Kind() == SyntaxKind.ExplicitInterfaceSpecifier)
			{
				return await GetCompletionsOffOfExplicitInterfaceAsync(
					engine, document, semanticModel, position, ((ExplicitInterfaceSpecifierSyntax)node).Name, cancellationToken).ConfigureAwait(false);
			}

			return Enumerable.Empty<CompletionData> ();
		}
        /// <summary>
        /// Traverses the symbol table processing XML documentation comments and optionally writing them to
        /// a provided stream.
        /// </summary>
        /// <param name="compilation">Compilation that owns the symbol table.</param>
        /// <param name="assemblyName">Assembly name override, if specified. Otherwise the <see cref="ISymbol.Name"/> of the source assembly is used.</param>
        /// <param name="xmlDocStream">Stream to which XML will be written, if specified.</param>
        /// <param name="diagnostics">Will be supplemented with documentation comment diagnostics.</param>
        /// <param name="cancellationToken">To stop traversing the symbol table early.</param>
        /// <param name="filterTree">Only report diagnostics from this syntax tree, if non-null.</param>
        /// <param name="filterSpanWithinTree">If <paramref name="filterTree"/> and filterSpanWithinTree is non-null, report diagnostics within this span in the <paramref name="filterTree"/>.</param>
        public static void WriteDocumentationCommentXml(CSharpCompilation compilation, string assemblyName, Stream xmlDocStream, DiagnosticBag diagnostics, CancellationToken cancellationToken, SyntaxTree filterTree = null, TextSpan? filterSpanWithinTree = null)
        {
            StreamWriter writer = null;
            if (xmlDocStream != null && xmlDocStream.CanWrite)
            {
                writer = new StreamWriter(
                    stream: xmlDocStream,
                    encoding: new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: false),
                    bufferSize: 0x400, // Default.
                    leaveOpen: true); // Don't close caller's stream.
            }

            using (writer)
            {
                var compiler = new DocumentationCommentCompiler(assemblyName ?? compilation.SourceAssembly.Name, compilation, writer, filterTree, filterSpanWithinTree,
                    processIncludes: true, isForSingleSymbol: false, diagnostics: diagnostics, cancellationToken: cancellationToken);
                compiler.Visit(compilation.SourceAssembly.GlobalNamespace);
                Debug.Assert(compiler._indentDepth == 0);
            }

            if (filterTree != null)
            {
                // Will respect the DocumentationMode.
                UnprocessedDocumentationCommentFinder.ReportUnprocessed(filterTree, filterSpanWithinTree, diagnostics, cancellationToken);
            }
            else
            {
                foreach (SyntaxTree tree in compilation.SyntaxTrees)
                {
                    // Will respect the DocumentationMode.
                    UnprocessedDocumentationCommentFinder.ReportUnprocessed(tree, null, diagnostics, cancellationToken);
                }
            }
        }
        protected void Test(string code,
           string allCode,
           Tuple<string, string>[] expected,
           CSharpParseOptions options = null)
        {
            var start = allCode.IndexOf(code);
            var length = code.Length;
            var span = new TextSpan(start, length);

            var actual = GetClassificationSpans(allCode, span, options: options).ToList();

            actual.Sort((t1, t2) => t1.TextSpan.Start - t2.TextSpan.Start);

            var max = Math.Max(expected.Length, actual.Count);
            for (int i = 0; i < max; i++)
            {
                if (i >= expected.Length)
                {
                    AssertEx.Fail("Unexpected actual classification: {0}", GetText(actual[i]));
                }
                else if (i >= actual.Count)
                {
                    AssertEx.Fail("Missing classification for: {0}", GetText(expected[i]));
                }

                var tuple = expected[i];
                var classification = actual[i];

                var text = allCode.Substring(classification.TextSpan.Start, classification.TextSpan.Length);
                Assert.Equal(tuple.Item1, text);
                Assert.Equal(tuple.Item2, classification.ClassificationType);
            }
        }
        public SourceDefinitionTreeItem(Document document, TextSpan sourceSpan, ISymbol symbol, ushort glyphIndex)
            : base(document, sourceSpan, glyphIndex)
        {
            _symbolDisplay = symbol.ToDisplayString(definitionDisplayFormat);

            this.DisplayText = $"[{document.Project.Name}] {_symbolDisplay}";
        }
 public XmlDocCommentCompletionItem(CompletionListProvider provider,
     TextSpan filterSpan,
     string displayText,
     CompletionItemRules rules)
     : this(provider, filterSpan, displayText, displayText, string.Empty, rules)
 {
 }
 public static IOpenParenToken OpenParen(TextSpan span)
 {
     return(new OpenParenToken(span));
 }
 public PlusToken(TextSpan span)
     : base(span)
 {
 }
 public NotEqualToken(TextSpan span)
     : base(span)
 {
 }
 public static IColonToken Colon(TextSpan span)
 {
     return(new ColonToken(span));
 }
 public EqualsEqualsToken(TextSpan span)
     : base(span)
 {
 }
 public SlashToken(TextSpan span)
     : base(span)
 {
 }
 public AsteriskToken(TextSpan span)
     : base(span)
 {
 }
 public MinusToken(TextSpan span)
     : base(span)
 {
 }
 public LessThanDotDotLessThanToken(TextSpan span)
     : base(span)
 {
 }
 public static ICommaToken Comma(TextSpan span)
 {
     return(new CommaToken(span));
 }
 public ColonColonDotToken(TextSpan span)
     : base(span)
 {
 }
 public DotDotToken(TextSpan span)
     : base(span)
 {
 }
 public RightArrowToken(TextSpan span)
     : base(span)
 {
 }
 public static ISemicolonToken Semicolon(TextSpan span)
 {
     return(new SemicolonToken(span));
 }
 public CommaToken(TextSpan span)
     : base(span)
 {
 }
 public ColonToken(TextSpan span)
     : base(span)
 {
 }
 public CloseParenToken(TextSpan span)
     : base(span)
 {
 }
 public SemicolonToken(TextSpan span)
     : base(span)
 {
 }
 public OpenParenToken(TextSpan span)
     : base(span)
 {
 }
 public static ICloseParenToken CloseParen(TextSpan span)
 {
     return(new CloseParenToken(span));
 }
 public OpenBraceToken(TextSpan span)
     : base(span)
 {
 }
 public CloseBraceToken(TextSpan span)
     : base(span)
 {
 }
 public GreaterThanToken(TextSpan span)
     : base(span)
 {
 }
 public EndOfFileToken(TextSpan span)
     : base(span)
 {
 }
 public static ICloseBraceToken CloseBrace(TextSpan span)
 {
     return(new CloseBraceToken(span));
 }
 public static ILeftWaveArrowToken LeftWaveArrow(TextSpan span)
 {
     return(new LeftWaveArrowToken(span));
 }
 public static IQuestionDotToken QuestionDot(TextSpan span)
 {
     return(new QuestionDotToken(span));
 }
 public static IRightWaveArrowToken RightWaveArrow(TextSpan span)
 {
     return(new RightWaveArrowToken(span));
 }
 public static ISlashEqualsToken SlashEquals(TextSpan span)
 {
     return(new SlashEqualsToken(span));
 }
 public static ILessThanColonToken LessThanColon(TextSpan span)
 {
     return(new LessThanColonToken(span));
 }