public override void VisitUsingDirective(UsingDirectiveSyntax node) { //if (node.Name.ToString() != "System" && !node.Name.ToString().StartsWith("System.")) //{ this.Usings.Add(node); //} }
protected override void VisitUsingDirective(UsingDirectiveSyntax node) { if (node.Name.GetText() != "System" && !node.Name.GetText().StartsWith("System.")) { Usings.Add(node); } }
public override void VisitUsingDirective(UsingDirectiveSyntax node) { if (node.IsInSystemWindows() && !uiClass) { uiClass = true; Result.generalAsyncResults.NumUIClasses++; } base.VisitUsingDirective(node); }
public static CompilationUnitSyntax AddUsingDirective( this CompilationUnitSyntax root, UsingDirectiveSyntax usingDirective, SyntaxNode contextNode, bool placeSystemNamespaceFirst, params SyntaxAnnotation[] annotations) { return root.AddUsingDirectives(new[] { usingDirective }, contextNode, placeSystemNamespaceFirst, annotations); }
// Hay un visit por cada tipo de nodo. Es bastante útil. public override void VisitUsingDirective(UsingDirectiveSyntax node) { // Propiedad últil de los nodos: CSharpKind (en este caso sería siempre UsingDirective) /*Note the Name property of type NameSyntax; this stores the name of the namespace being imported.*/ if (node.Name.ToString() != "System" && !node.Name.ToString().StartsWith("System.")) { this.Usings.Add(node); } }
private static SyntaxToken? GetFirstIdentifierInUsingDirective(UsingDirectiveSyntax usingDirective) { foreach (var identifier in usingDirective.DescendantNodes()) { IdentifierNameSyntax identifierName = identifier as IdentifierNameSyntax; if (identifierName != null && ExcludeGlobalKeyword(identifierName)) { return identifierName.Identifier; } } return null; }
public override SyntaxNode VisitUsingDirective(UsingDirectiveSyntax node) { if (node == null) { throw new ArgumentNullException(nameof(node)); } if (node.UsingKeyword.TrailingTrivia.FullSpan.IsEmpty) { node = node.WithUsingKeyword(node.UsingKeyword.WithTrailingTrivia(SyntaxFactory.Space)); } if (node.SemicolonToken.TrailingTrivia.FullSpan.IsEmpty) { node = node.WithSemicolonToken(node.SemicolonToken.WithTrailingTrivia(this.newLineTrivia)); } return node; }
//Note:It must exist, to shortcut visit the using [XXX], otherwise it will visit XXX public override SyntaxNode VisitUsingDirective(UsingDirectiveSyntax node) { if (node.Alias != null) { this.AppendCompileIssue(node, IssueType.Error, IssueId.UsingAliasNotSupport); } else { if (_template.SupportUsing) { var template = _template.CreateUsingTemplate(); _output.Write(node, template.GetBeginString()); this.Visit(node.Name); _output.TrivialWriteLine(template.GetEndString()); } } return node; }
public override void VisitUsingDirective(UsingDirectiveSyntax node) { // these could theoretically be acquired by indexing the GAC or something var namespaces = new List<String> { "System", "System.Collections", "System.Collections.Generic", "System.Text", "System.Linq" }; string whatAreWeUsing = node.Name.ToString(); if (!namespaces.Contains(whatAreWeUsing)) { var parts = whatAreWeUsing.Split('.'); cb.AppendIndent().Append("using namespace ").Append(string.Join("::", parts)).AppendLine(";"); } }
private static UsingDirectiveSyntax RemoveLeadingAndTrailingCompilerDirectives(UsingDirectiveSyntax usingSyntax) { UsingDirectiveSyntax usingDirectiveToUse = usingSyntax; if (usingDirectiveToUse.HasLeadingTrivia) { if (usingDirectiveToUse.HasLeadingTrivia) { var newLeadingTrivia = RemoveCompilerDirectives(usingDirectiveToUse.GetLeadingTrivia()); usingDirectiveToUse = usingDirectiveToUse.WithLeadingTrivia(newLeadingTrivia); } if (usingDirectiveToUse.HasTrailingTrivia) { var newTrailingTrivia = RemoveCompilerDirectives(usingDirectiveToUse.GetTrailingTrivia()); usingDirectiveToUse = usingDirectiveToUse.WithTrailingTrivia(newTrailingTrivia); } } return usingDirectiveToUse; }
private IEnumerable<ClassifiedSpan> ClassifyUsingDirectiveSyntax( UsingDirectiveSyntax usingDirective, SemanticModel semanticModel, CancellationToken cancellationToken) { // For using aliases, we bind the target on the right of the equals and use that // binding to classify the alias. if (usingDirective.Alias != null) { var info = semanticModel.GetTypeInfo(usingDirective.Name, cancellationToken); if (info.Type != null) { var classification = GetClassificationForType(info.Type); if (classification != null) { var token = usingDirective.Alias.Name; return SpecializedCollections.SingletonEnumerable(new ClassifiedSpan(token.Span, classification)); } } } return null; }
private static string GetAliasName(UsingDirectiveSyntax usingDirective) { return (usingDirective.Alias == null || usingDirective.Alias.Name == null) ? null : usingDirective.Alias.Name.ToString(); }
private static bool UsingsMatch(UsingDirectiveSyntax usingDirective1, UsingDirectiveSyntax usingDirective2) { return usingDirective1.Name.ToString() == usingDirective2.Name.ToString() && GetAliasName(usingDirective1) == GetAliasName(usingDirective2); }
static bool IsBindingFlags(UsingDirectiveSyntax @using) { return(@using.StaticKeyword.IsKind(SyntaxKind.StaticKeyword) && @using.Name is QualifiedNameSyntax qn && qn.Right.Identifier.ValueText == "BindingFlags"); }
private static async Task <Document> ReplaceOrInsertNewUsingDirectivePreview(Document document, UsingDirectiveSyntax oldDirective, CancellationToken cancellationToken) { return(await ReplaceOrInsertNewUsingDirective(document, oldDirective, false, cancellationToken).ConfigureAwait(false)); }
private int CompareUsings(UsingDirectiveSyntax left, UsingDirectiveSyntax right) { if ((left.Alias != null) && (right.Alias != null)) { return CultureInfo.InvariantCulture.CompareInfo.Compare(left.Alias.Name.Identifier.ValueText, right.Alias.Name.Identifier.ValueText, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreWidth); } bool leftIsSystem = this.IsSeparatedSystemUsing(left); bool rightIsSystem = this.IsSeparatedSystemUsing(right); if (leftIsSystem != rightIsSystem) { return leftIsSystem ? -1 : 1; } return CultureInfo.InvariantCulture.CompareInfo.Compare(left.Name.ToNormalizedString(), right.Name.ToNormalizedString(), CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreWidth); }
private static bool HasNamespaceAliasQualifier(UsingDirectiveSyntax usingDirective) => usingDirective.DescendantNodes().Any(node => node.IsKind(SyntaxKind.AliasQualifiedName));
public override void VisitUsingDirective(UsingDirectiveSyntax node) { PrintLn("open {0}", node.Name); }
private void Validate() { if (this == Empty) { return; } DiagnosticBag semanticDiagnostics = _compilation.DeclarationDiagnostics; // Check constraints within named aliases. var diagnostics = BindingDiagnosticBag.GetInstance(); // Force resolution of named aliases. foreach (var(_, alias) in UsingAliases) { NamespaceOrTypeSymbol target = alias.Alias.GetAliasTarget(basesBeingResolved: null); diagnostics.Clear(); diagnostics.AddRange(alias.Alias.AliasTargetDiagnostics); alias.Alias.CheckConstraints(diagnostics); semanticDiagnostics.AddRange(diagnostics.DiagnosticBag); recordImportDependencies(alias.UsingDirective, target); } var corLibrary = _compilation.SourceAssembly.CorLibrary; var conversions = new TypeConversions(corLibrary); foreach (var @using in Usings) { diagnostics.Clear(); diagnostics.AddDependencies(@using.Dependencies); NamespaceOrTypeSymbol target = @using.NamespaceOrType; // Check if `using static` directives meet constraints. UsingDirectiveSyntax usingDirective = @using.UsingDirective; if (target.IsType) { var typeSymbol = (TypeSymbol)target; var location = usingDirective?.Name.Location ?? NoLocation.Singleton; typeSymbol.CheckAllConstraints(_compilation, conversions, location, diagnostics); } semanticDiagnostics.AddRange(diagnostics.DiagnosticBag); recordImportDependencies(usingDirective, target); } // Force resolution of extern aliases. foreach (var alias in ExternAliases) { var target = (NamespaceSymbol)alias.Alias.GetAliasTarget(null); Debug.Assert(target.IsGlobalNamespace); semanticDiagnostics.AddRange(alias.Alias.AliasTargetDiagnostics.DiagnosticBag); if (!Compilation.ReportUnusedImportsInTree(alias.ExternAliasDirective.SyntaxTree)) { diagnostics.Clear(); diagnostics.AddAssembliesUsedByNamespaceReference(target); _compilation.AddUsedAssemblies(diagnostics.DependenciesBag); } } if (_diagnostics != null && !_diagnostics.IsEmptyWithoutResolution) { semanticDiagnostics.AddRange(_diagnostics.AsEnumerable()); } diagnostics.Free(); void recordImportDependencies(UsingDirectiveSyntax usingDirective, NamespaceOrTypeSymbol target) { if (usingDirective is object && Compilation.ReportUnusedImportsInTree(usingDirective.SyntaxTree)) { _compilation.RecordImportDependencies(usingDirective, diagnostics.DependenciesBag.ToImmutableArray()); } else { if (target.IsNamespace) { diagnostics.AddAssembliesUsedByNamespaceReference((NamespaceSymbol)target); } _compilation.AddUsedAssemblies(diagnostics.DependenciesBag); } } }
private static string GetAliasName(UsingDirectiveSyntax usingDirective) #pragma warning restore IDE0051 // Remove unused private members { return((usingDirective.Alias == null || usingDirective.Alias.Name == null) ? null : usingDirective.Alias.Name.ToString()); }
private static void AnalyzeUsings(SyntaxNodeAnalysisContext context, SyntaxList <UsingDirectiveSyntax> usings) { int count = usings.Count; if (count <= 1) { return; } UsingDirectiveSyntax usingDirective1 = usings[0]; for (int i = 1; i < count; i++, usingDirective1 = usings[i - 1]) { if (usingDirective1.StaticKeyword.IsKind(SyntaxKind.StaticKeyword)) { return; } if (usingDirective1.Alias != null) { return; } UsingDirectiveSyntax usingDirective2 = usings[i]; if (usingDirective2.StaticKeyword.IsKind(SyntaxKind.StaticKeyword)) { return; } if (usingDirective2.Alias != null) { return; } SyntaxTriviaList trailingTrivia = usingDirective1.GetTrailingTrivia(); if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailingTrivia)) { continue; } IdentifierNameSyntax rootNamespace1 = usingDirective1.GetRootNamespace(); if (rootNamespace1 == null) { continue; } IdentifierNameSyntax rootNamespace2 = usingDirective2.GetRootNamespace(); if (rootNamespace2 == null) { continue; } SyntaxTriviaList leadingTrivia = usingDirective2.GetLeadingTrivia(); bool isEmptyLine = SyntaxTriviaAnalysis.StartsWithOptionalWhitespaceThenEndOfLineTrivia(leadingTrivia); if (string.Equals(rootNamespace1.Identifier.ValueText, rootNamespace2.Identifier.ValueText, StringComparison.Ordinal)) { if (isEmptyLine) { ReportDiagnostic( context, DiagnosticDescriptors.RemoveEmptyLineBetweenUsingDirectivesWithSameRootNamespace, leadingTrivia[0]); } } else if (isEmptyLine) { ReportDiagnostic( context, DiagnosticDescriptors.RemoveEmptyLineBetweenUsingDirectivesWithDifferentRootNamespace, leadingTrivia[0]); } else { ReportDiagnostic( context, DiagnosticDescriptors.AddEmptyLineBetweenUsingDirectivesWithDifferentRootNamespace, trailingTrivia.Last()); } } }
public override void VisitUsingDirective(UsingDirectiveSyntax Node) { base.VisitUsingDirective(Node); Usings.Add(Node.Name.ToString()); }
public void AddUsing(UsingDirectiveSyntax directive) { set.Add(directive.NormalizeWhitespace()); }
private static async Task <Document> ReplaceOrInsertNewUsingDirective(Document document, UsingDirectiveSyntax oldDirective, bool shouldUseQualifiedName, CancellationToken cancellationToken) { var @namespace = oldDirective.Name; var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); if (syntaxRoot is not CompilationUnitSyntax compilation) { return(document); } var isRequireNewUsingDirective = compilation.Usings.None(w => w.Alias.IsKind(SyntaxKind.None) && w.Name.IsEquivalentTo(@namespace, true)); if (isRequireNewUsingDirective && !shouldUseQualifiedName) { UsingDirectiveSyntax ReplaceStaticDirective(UsingDirectiveSyntax directive) { if (directive.IsEquivalentTo(oldDirective)) { return(directive.WithAlias(null)); } return(directive); } var usings = compilation.Usings.Select(ReplaceStaticDirective).ToList(); return(await document.ReplaceNodeAsync(compilation, compilation.WithUsings(SyntaxFactory.List(usings)), cancellationToken).ConfigureAwait(false)); } else { var usings = compilation.Usings.Where(w => !w.IsEquivalentTo(oldDirective)).ToList(); return(await document.ReplaceNodeAsync(compilation, compilation.WithUsings(SyntaxFactory.List(usings)), cancellationToken).ConfigureAwait(false)); } }
private VirtualTreePoint GetStartPoint(SourceText text, UsingDirectiveSyntax node, EnvDTE.vsCMPart part) { int startPosition; switch (part) { case EnvDTE.vsCMPart.vsCMPartName: case EnvDTE.vsCMPart.vsCMPartAttributes: case EnvDTE.vsCMPart.vsCMPartHeader: case EnvDTE.vsCMPart.vsCMPartWhole: case EnvDTE.vsCMPart.vsCMPartBodyWithDelimiter: case EnvDTE.vsCMPart.vsCMPartHeaderWithAttributes: throw Exceptions.ThrowENotImpl(); case EnvDTE.vsCMPart.vsCMPartAttributesWithDelimiter: case EnvDTE.vsCMPart.vsCMPartBody: throw Exceptions.ThrowEFail(); case EnvDTE.vsCMPart.vsCMPartWholeWithAttributes: startPosition = node.SpanStart; break; case EnvDTE.vsCMPart.vsCMPartNavigate: startPosition = node.Name.SpanStart; break; default: throw Exceptions.ThrowEInvalidArg(); } return new VirtualTreePoint(node.SyntaxTree, text, startPosition); }
public override SyntaxNode VisitUsingDirective(UsingDirectiveSyntax node) { node = node.ReplaceUsing(oldUsing: Transformer.MSTEST_USING, newUsing: Transformer.XUNIT_USING); return(base.VisitUsingDirective(node)); }
private static int CompareSpanStart(UsingDirectiveSyntax left, UsingDirectiveSyntax right) { return left.SpanStart - right.SpanStart; }
/// <summary> /// Check if <see cref="UsingDirectiveSyntax"/> is system using directive. /// </summary> /// <param name="usingDirective">The <see cref="UsingDirectiveSyntax"/> that will be checked.</param> /// <returns>Return true if the <see cref="UsingDirectiveSyntax"/>is system using directive, otherwise false.</returns> internal static bool IsSystemUsingDirective(this UsingDirectiveSyntax usingDirective) => string.Equals(SystemUsingDirectiveIdentifier, GetFirstIdentifierInUsingDirective(usingDirective)?.ValueText, StringComparison.Ordinal);
private void AddUsingDirective(Dictionary<DirectiveSpan, List<UsingDirectiveSyntax>> container, UsingDirectiveSyntax usingDirective, DirectiveSpan owningSpan) { List<UsingDirectiveSyntax> usingList; if (!container.TryGetValue(owningSpan, out usingList)) { usingList = new List<UsingDirectiveSyntax>(); container.Add(owningSpan, usingList); } usingList.Add(usingDirective); }
/// <summary> /// Check if the name of using directive contains a namespace alias qualifier. /// </summary> /// <param name="usingDirective">The <see cref="UsingDirectiveSyntax"/> that will be checked.</param> /// <returns> /// <see langword="true"/> if the <see cref="UsingDirectiveSyntax"/> contains a namespace alias qualifier; /// otherwise, <see langword="false"/>. /// </returns> internal static bool HasNamespaceAliasQualifier(this UsingDirectiveSyntax usingDirective) => usingDirective.DescendantNodes().Any(node => node.IsKind(SyntaxKind.AliasQualifiedName));
private static async Task <bool> ShouldUseQualifiedNameInChanges(Document document, UsingDirectiveSyntax oldDirective, IEnumerable <SyntaxNode> references, CancellationToken cancellationToken) { // apply the changes once and get if there are any compilation errors. var indeterminateDocument = await ReplaceOrInsertNewUsingDirectivePreview(document, oldDirective, cancellationToken).ConfigureAwait(false); var determinateDocument = await ResolveMissingReferencesPreview(indeterminateDocument, oldDirective, references, cancellationToken).ConfigureAwait(false); var semanticModel = await determinateDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var diagnostics = semanticModel.GetDiagnostics(null, cancellationToken); return(diagnostics.Any(w => w.Severity == DiagnosticSeverity.Error && w.Id == "CS0104" && w.Descriptor.Category == "Compiler")); }
/// <summary> /// Checks if the Name part of the given using directive starts with an alias. /// </summary> /// <param name="usingDirective">The <see cref="UsingDirectiveSyntax"/> that will be used.</param> /// <param name="semanticModel">The <see cref="SemanticModel"/> that will be used.</param> /// <param name="cancellationToken">The cancellation token that can be used to interrupt the operation.</param> /// <returns>True if the name part of the using directive starts with an alias.</returns> internal static bool StartsWithAlias(this UsingDirectiveSyntax usingDirective, SemanticModel semanticModel, CancellationToken cancellationToken) { var firstPart = usingDirective.Name.DescendantNodes().FirstOrDefault() ?? usingDirective.Name; return(semanticModel.GetAliasInfo(firstPart, cancellationToken) != null); }
public CsImportedNamespace(INamespaceSymbol namespaceSymbol, UsingDirectiveSyntax syntaxNode) : base(namespaceSymbol) { _syntaxNode = syntaxNode; }
public override void Visit(SyntaxNode node) { Tabs++; // Tabs are too much. // var indents = new String('\t', Tabs); var indents = new String(' ', Tabs * 5); Console.WriteLine(indents + node.Kind()); // Console.WriteLine(indents + "Add: " + node.GetDebuggerDisplay()); Console.WriteLine(indents + "Enum value: " + node.RawKind); // Console.WriteLine(indents + "Add: " + node.ToString()); // Check for the syntax kind (only on what would be more abstract syntax tree nodes). switch (node.Kind()) { // names & type-names case SyntaxKind.IdentifierName: // = 8616, break; case SyntaxKind.QualifiedName: // = 8617, Console.WriteLine("Sorry, not implemented! node.Kind = " + node.Kind()); QualifiedNameSyntax qualifiedNameNode = node as QualifiedNameSyntax; Console.WriteLine(" --- qualifiedNameNode.Kind = " + qualifiedNameNode.Kind()); // Console.WriteLine(" --- qualifiedNameNode.Qualifier = " + qualifiedNameNode.Qualifier()); // Console.WriteLine(" --- qualifiedNameNode.Name = " + qualifiedNameNode.Name()); // Console.WriteLine(" --- qualifiedNameNode.Qualifier = " + qualifiedNameNode.Identifier); // Console.WriteLine(" --- qualifiedNameNode.Name = " + qualifiedNameNode.Name()); // Console.WriteLine(" --- qualifiedNameNode.Name = " + qualifiedNameNode.GetUnqualifiedName); Console.WriteLine(" --- qualifiedNameNode.Left = " + qualifiedNameNode.Left); Console.WriteLine(" --- qualifiedNameNode.Right = " + qualifiedNameNode.Right); break; case SyntaxKind.GenericName: // = 8618, case SyntaxKind.TypeArgumentList: // = 8619, case SyntaxKind.AliasQualifiedName: // = 8620, case SyntaxKind.PredefinedType: // = 8621, case SyntaxKind.ArrayType: // = 8622, case SyntaxKind.ArrayRankSpecifier: // = 8623, case SyntaxKind.PointerType: // = 8624, case SyntaxKind.NullableType: // = 8625, case SyntaxKind.OmittedTypeArgument: // = 8626, break; // expressions case SyntaxKind.ParenthesizedExpression: // = 8632, case SyntaxKind.ConditionalExpression: // = 8633, case SyntaxKind.InvocationExpression: // = 8634, case SyntaxKind.ElementAccessExpression: // = 8635, case SyntaxKind.ArgumentList: // = 8636, case SyntaxKind.BracketedArgumentList: // = 8637, case SyntaxKind.Argument: // = 8638, case SyntaxKind.NameColon: // = 8639, case SyntaxKind.CastExpression: // = 8640, case SyntaxKind.AnonymousMethodExpression: // = 8641, case SyntaxKind.SimpleLambdaExpression: // = 8642, case SyntaxKind.ParenthesizedLambdaExpression: // = 8643, case SyntaxKind.ObjectInitializerExpression: // = 8644, case SyntaxKind.CollectionInitializerExpression: // = 8645, case SyntaxKind.ArrayInitializerExpression: // = 8646, case SyntaxKind.AnonymousObjectMemberDeclarator: // = 8647, case SyntaxKind.ComplexElementInitializerExpression: // = 8648, case SyntaxKind.ObjectCreationExpression: // = 8649, case SyntaxKind.AnonymousObjectCreationExpression: // = 8650, case SyntaxKind.ArrayCreationExpression: // = 8651, case SyntaxKind.ImplicitArrayCreationExpression: // = 8652, case SyntaxKind.StackAllocArrayCreationExpression: // = 8653, case SyntaxKind.OmittedArraySizeExpression: // = 8654, case SyntaxKind.InterpolatedStringExpression: // = 8655, case SyntaxKind.ImplicitElementAccess: // = 8656, case SyntaxKind.IsPatternExpression: // = 8657, break; // binary expressions case SyntaxKind.AddExpression: // = 8668, case SyntaxKind.SubtractExpression: // = 8669, case SyntaxKind.MultiplyExpression: // = 8670, case SyntaxKind.DivideExpression: // = 8671, case SyntaxKind.ModuloExpression: // = 8672, case SyntaxKind.LeftShiftExpression: // = 8673, case SyntaxKind.RightShiftExpression: // = 8674, case SyntaxKind.LogicalOrExpression: // = 8675, case SyntaxKind.LogicalAndExpression: // = 8676, case SyntaxKind.BitwiseOrExpression: // = 8677, case SyntaxKind.BitwiseAndExpression: // = 8678, case SyntaxKind.ExclusiveOrExpression: // = 8679, case SyntaxKind.EqualsExpression: // = 8680, case SyntaxKind.NotEqualsExpression: // = 8681, case SyntaxKind.LessThanExpression: // = 8682, case SyntaxKind.LessThanOrEqualExpression: // = 8683, case SyntaxKind.GreaterThanExpression: // = 8684, case SyntaxKind.GreaterThanOrEqualExpression: // = 8685, case SyntaxKind.IsExpression: // = 8686, case SyntaxKind.AsExpression: // = 8687, case SyntaxKind.CoalesceExpression: // = 8688, case SyntaxKind.SimpleMemberAccessExpression: // = 8689, // dot access: a.b case SyntaxKind.PointerMemberAccessExpression: // = 8690, // arrow access: a->b case SyntaxKind.ConditionalAccessExpression: // = 8691, // question mark access: a?.b , a?[1] break; // binding expressions case SyntaxKind.MemberBindingExpression: // = 8707, case SyntaxKind.ElementBindingExpression: // = 8708, break; // binary assignment expressions case SyntaxKind.SimpleAssignmentExpression: // = 8714, case SyntaxKind.AddAssignmentExpression: // = 8715, case SyntaxKind.SubtractAssignmentExpression: // = 8716, case SyntaxKind.MultiplyAssignmentExpression: // = 8717, case SyntaxKind.DivideAssignmentExpression: // = 8718, case SyntaxKind.ModuloAssignmentExpression: // = 8719, case SyntaxKind.AndAssignmentExpression: // = 8720, case SyntaxKind.ExclusiveOrAssignmentExpression: // = 8721, case SyntaxKind.OrAssignmentExpression: // = 8722, case SyntaxKind.LeftShiftAssignmentExpression: // = 8723, case SyntaxKind.RightShiftAssignmentExpression: // = 8724, break; // unary expressions case SyntaxKind.UnaryPlusExpression: // = 8730, case SyntaxKind.UnaryMinusExpression: // = 8731, case SyntaxKind.BitwiseNotExpression: // = 8732, case SyntaxKind.LogicalNotExpression: // = 8733, case SyntaxKind.PreIncrementExpression: // = 8734, case SyntaxKind.PreDecrementExpression: // = 8735, case SyntaxKind.PointerIndirectionExpression: // = 8736, case SyntaxKind.AddressOfExpression: // = 8737, case SyntaxKind.PostIncrementExpression: // = 8738, case SyntaxKind.PostDecrementExpression: // = 8739, case SyntaxKind.AwaitExpression: // = 8740, break; // primary expression case SyntaxKind.ThisExpression: // = 8746, case SyntaxKind.BaseExpression: // = 8747, case SyntaxKind.ArgListExpression: // = 8748, case SyntaxKind.NumericLiteralExpression: // = 8749, case SyntaxKind.StringLiteralExpression: // = 8750, case SyntaxKind.CharacterLiteralExpression: // = 8751, case SyntaxKind.TrueLiteralExpression: // = 8752, case SyntaxKind.FalseLiteralExpression: // = 8753, case SyntaxKind.NullLiteralExpression: // = 8754, case SyntaxKind.DefaultLiteralExpression: // = 8755, break; // primary function expressions case SyntaxKind.TypeOfExpression: // = 8760, case SyntaxKind.SizeOfExpression: // = 8761, case SyntaxKind.CheckedExpression: // = 8762, case SyntaxKind.UncheckedExpression: // = 8763, case SyntaxKind.DefaultExpression: // = 8764, case SyntaxKind.MakeRefExpression: // = 8765, case SyntaxKind.RefValueExpression: // = 8766, case SyntaxKind.RefTypeExpression: // = 8767, break; // NameOfExpression: // = 8768, // we represent nameof(x) as an invocation expression // query expressions case SyntaxKind.QueryExpression: // = 8774, case SyntaxKind.QueryBody: // = 8775, case SyntaxKind.FromClause: // = 8776, case SyntaxKind.LetClause: // = 8777, case SyntaxKind.JoinClause: // = 8778, case SyntaxKind.JoinIntoClause: // = 8779, case SyntaxKind.WhereClause: // = 8780, case SyntaxKind.OrderByClause: // = 8781, case SyntaxKind.AscendingOrdering: // = 8782, case SyntaxKind.DescendingOrdering: // = 8783, case SyntaxKind.SelectClause: // = 8784, case SyntaxKind.GroupClause: // = 8785, case SyntaxKind.QueryContinuation: // = 8786, break; // statements case SyntaxKind.Block: // = 8792, case SyntaxKind.LocalDeclarationStatement: // = 8793, case SyntaxKind.VariableDeclaration: // = 8794, case SyntaxKind.VariableDeclarator: // = 8795, case SyntaxKind.EqualsValueClause: // = 8796, case SyntaxKind.ExpressionStatement: // = 8797, case SyntaxKind.EmptyStatement: // = 8798, case SyntaxKind.LabeledStatement: // = 8799, break; // jump statements case SyntaxKind.GotoStatement: // = 8800, case SyntaxKind.GotoCaseStatement: // = 8801, case SyntaxKind.GotoDefaultStatement: // = 8802, case SyntaxKind.BreakStatement: // = 8803, case SyntaxKind.ContinueStatement: // = 8804, case SyntaxKind.ReturnStatement: // = 8805, case SyntaxKind.YieldReturnStatement: // = 8806, case SyntaxKind.YieldBreakStatement: // = 8807, case SyntaxKind.ThrowStatement: // = 8808, break; case SyntaxKind.WhileStatement: // = 8809, case SyntaxKind.DoStatement: // = 8810, case SyntaxKind.ForStatement: // = 8811, case SyntaxKind.ForEachStatement: // = 8812, break; case SyntaxKind.UsingStatement: // = 8813, Console.WriteLine("Sorry, not implemented! node.Kind = " + node.Kind()); break; case SyntaxKind.FixedStatement: // = 8814, break; // checked statements case SyntaxKind.CheckedStatement: // = 8815, case SyntaxKind.UncheckedStatement: // = 8816, break; case SyntaxKind.UnsafeStatement: // = 8817, case SyntaxKind.LockStatement: // = 8818, case SyntaxKind.IfStatement: // = 8819, case SyntaxKind.ElseClause: // = 8820, case SyntaxKind.SwitchStatement: // = 8821, case SyntaxKind.SwitchSection: // = 8822, case SyntaxKind.CaseSwitchLabel: // = 8823, case SyntaxKind.DefaultSwitchLabel: // = 8824, case SyntaxKind.TryStatement: // = 8825, case SyntaxKind.CatchClause: // = 8826, case SyntaxKind.CatchDeclaration: // = 8827, case SyntaxKind.CatchFilterClause: // = 8828, case SyntaxKind.FinallyClause: // = 8829, break; // statements that didn't fit above case SyntaxKind.LocalFunctionStatement: // = 8830, break; // declarations case SyntaxKind.CompilationUnit: // = 8840, case SyntaxKind.GlobalStatement: // = 8841, case SyntaxKind.NamespaceDeclaration: // = 8842, break; case SyntaxKind.UsingDirective: // = 8843, Console.WriteLine("Sorry, not implemented! node.Kind = " + node.Kind()); UsingDirectiveSyntax usingDirectiveNode = node as UsingDirectiveSyntax; Console.WriteLine(" --- usingDirectiveNode.Kind = " + usingDirectiveNode.Kind()); Console.WriteLine(" --- usingDirectiveNode.Name = " + usingDirectiveNode.Name); break; case SyntaxKind.ExternAliasDirective: // = 8844, break; // attributes case SyntaxKind.AttributeList: // = 8847, case SyntaxKind.AttributeTargetSpecifier: // = 8848, case SyntaxKind.Attribute: // = 8849, case SyntaxKind.AttributeArgumentList: // = 8850, case SyntaxKind.AttributeArgument: // = 8851, case SyntaxKind.NameEquals: // = 8852, break; // type declarations case SyntaxKind.ClassDeclaration: // = 8855, case SyntaxKind.StructDeclaration: // = 8856, case SyntaxKind.InterfaceDeclaration: // = 8857, case SyntaxKind.EnumDeclaration: // = 8858, case SyntaxKind.DelegateDeclaration: // = 8859, break; case SyntaxKind.BaseList: // = 8864, case SyntaxKind.SimpleBaseType: // = 8865, case SyntaxKind.TypeParameterConstraintClause: // = 8866, case SyntaxKind.ConstructorConstraint: // = 8867, case SyntaxKind.ClassConstraint: // = 8868, case SyntaxKind.StructConstraint: // = 8869, case SyntaxKind.TypeConstraint: // = 8870, case SyntaxKind.ExplicitInterfaceSpecifier: // = 8871, case SyntaxKind.EnumMemberDeclaration: // = 8872, case SyntaxKind.FieldDeclaration: // = 8873, case SyntaxKind.EventFieldDeclaration: // = 8874, case SyntaxKind.MethodDeclaration: // = 8875, case SyntaxKind.OperatorDeclaration: // = 8876, case SyntaxKind.ConversionOperatorDeclaration: // = 8877, case SyntaxKind.ConstructorDeclaration: // = 8878, break; case SyntaxKind.BaseConstructorInitializer: // = 8889, case SyntaxKind.ThisConstructorInitializer: // = 8890, case SyntaxKind.DestructorDeclaration: // = 8891, case SyntaxKind.PropertyDeclaration: // = 8892, case SyntaxKind.EventDeclaration: // = 8893, case SyntaxKind.IndexerDeclaration: // = 8894, case SyntaxKind.AccessorList: // = 8895, case SyntaxKind.GetAccessorDeclaration: // = 8896, case SyntaxKind.SetAccessorDeclaration: // = 8897, case SyntaxKind.AddAccessorDeclaration: // = 8898, case SyntaxKind.RemoveAccessorDeclaration: // = 8899, case SyntaxKind.UnknownAccessorDeclaration: // = 8900, case SyntaxKind.ParameterList: // = 8906, case SyntaxKind.BracketedParameterList: // = 8907, case SyntaxKind.Parameter: // = 8908, case SyntaxKind.TypeParameterList: // = 8909, case SyntaxKind.TypeParameter: // = 8910, case SyntaxKind.IncompleteMember: // = 8916, case SyntaxKind.ArrowExpressionClause: // = 8917, break; default: Console.WriteLine("Error: default reached in switch over node.Kind = " + node.Kind()); break; } base.Visit(node); Tabs--; }
private static void AnalyzeCompilationUnit(SyntaxNodeAnalysisContext context) { var compilationUnit = (CompilationUnitSyntax)context.Node; UsingDirectiveSyntax usingDirective = compilationUnit.Usings.FirstOrDefault(); if (usingDirective == null) { return; } SyntaxTriviaList.Reversed.Enumerator en = usingDirective.GetLeadingTrivia().Reverse().GetEnumerator(); if (en.MoveNext()) { if (en.Current.IsWhitespaceTrivia() && !en.MoveNext()) { if (IsPrecededWithExternAliasDirective()) { ReportDiagnostic(usingDirective.SpanStart); } } else { switch (en.Current.Kind()) { case SyntaxKind.EndOfLineTrivia: { if (en.MoveNext() && en.Current.IsKind(SyntaxKind.SingleLineCommentTrivia)) { ReportDiagnostic(usingDirective.SpanStart); } break; } case SyntaxKind.RegionDirectiveTrivia: { SyntaxTrivia regionDirective = en.Current; if (en.MoveNext()) { if (en.Current.IsWhitespaceTrivia() && !en.MoveNext()) { if (IsPrecededWithExternAliasDirective()) { ReportDiagnostic(regionDirective.SpanStart); } } else if (en.Current.IsEndOfLineTrivia() && en.MoveNext() && en.Current.IsKind(SyntaxKind.SingleLineCommentTrivia)) { ReportDiagnostic(regionDirective.SpanStart); } } else if (IsPrecededWithExternAliasDirective()) { ReportDiagnostic(regionDirective.SpanStart); } break; } default: { if (en.Current.IsDirective) { ReportDiagnostic(usingDirective.SpanStart); } break; } } } } else if (IsPrecededWithExternAliasDirective()) { ReportDiagnostic(usingDirective.SpanStart); } bool IsPrecededWithExternAliasDirective() { ExternAliasDirectiveSyntax externAliasDirective = compilationUnit.Externs.LastOrDefault(); return(externAliasDirective?.FullSpan.End == usingDirective.FullSpan.Start && SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(externAliasDirective.GetTrailingTrivia())); } void ReportDiagnostic(int position) { context.ReportDiagnostic( DiagnosticDescriptors.AddEmptyLineBeforeUsingDirectiveList, Location.Create(compilationUnit.SyntaxTree, new TextSpan(position, 0))); } }
private static string GetAliasName(UsingDirectiveSyntax usingDirective) { return((usingDirective.Alias == null || usingDirective.Alias.Name == null) ? null : usingDirective.Alias.Name.ToString()); }
public override void VisitUsingDirective(UsingDirectiveSyntax node) { CheckForInvalid(node); base.VisitUsingDirective(node); }
public RichGenerationContext AddUsing(UsingDirectiveSyntax usingDirective) { Usings.Add(usingDirective); return(this); }
public override void VisitUsingDirective(UsingDirectiveSyntax node) { }
/// <inheritdoc /> /// <summary> /// Called when the visitor visits a UsingDirectiveSyntax node. /// </summary> /// <param name="node">Visited node</param> public override void VisitUsingDirective(UsingDirectiveSyntax node) { base.VisitUsingDirective(node); counter_++; }
/// <summary> /// Given a using declaration get the corresponding symbol for the using alias that was /// introduced. /// </summary> /// <param name="declarationSyntax"></param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The alias symbol that was declared.</returns> /// <remarks> /// If the using directive is an error because it attempts to introduce an alias for which an existing alias was /// previously declared in the same scope, the result is a newly-constructed AliasSymbol (i.e. not one from the /// symbol table). /// </remarks> public abstract IAliasSymbol GetDeclaredSymbol(UsingDirectiveSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken));
private static bool IsAliasOrStaticUsingDirective(UsingDirectiveSyntax usingDirective) => usingDirective.Alias != null || usingDirective.StaticKeyword.IsKind(SyntaxKind.StaticKeyword);
private static bool IsAliasOrStaticUsingDirective(UsingDirectiveSyntax usingDirective) => usingDirective.Alias != null || usingDirective.StaticKeyword.IsKind(SyntaxKind.StaticKeyword);
public override void VisitUsingDirective(UsingDirectiveSyntax node) { }
public override IAliasSymbol GetDeclaredSymbol(UsingDirectiveSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken)) { // Can't define alias inside member. return null; }
internal AliasSymbol(Binder binder, UsingDirectiveSyntax syntax) : this(binder, syntax.Alias.Name.Identifier) { _aliasTargetName = syntax.Name; }
private UsingDirectiveSyntax QualifyUsingDirective(UsingDirectiveSyntax usingDirective) { NameSyntax originalName = usingDirective.Name; NameSyntax rewrittenName; switch (originalName.Kind()) { case SyntaxKind.QualifiedName: case SyntaxKind.IdentifierName: case SyntaxKind.GenericName: if (originalName.Parent.IsKind(SyntaxKind.UsingDirective) || originalName.Parent.IsKind(SyntaxKind.TypeArgumentList)) { var symbol = this.semanticModel.GetSymbolInfo(originalName, cancellationToken: CancellationToken.None).Symbol; if (symbol == null) { rewrittenName = originalName; break; } if (symbol is INamespaceSymbol) { // TODO: Preserve inner trivia string fullName = symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat); NameSyntax replacement = SyntaxFactory.ParseName(fullName); if (!originalName.DescendantNodesAndSelf().OfType<AliasQualifiedNameSyntax>().Any()) { replacement = replacement.ReplaceNodes( replacement.DescendantNodesAndSelf().OfType<AliasQualifiedNameSyntax>(), (originalNode2, rewrittenNode2) => rewrittenNode2.Name); } rewrittenName = replacement.WithTriviaFrom(originalName); break; } else if (symbol is INamedTypeSymbol) { // TODO: Preserve inner trivia // TODO: simplify after qualification string fullName; if (SpecialTypeHelper.IsPredefinedType(((INamedTypeSymbol)symbol).OriginalDefinition.SpecialType)) { fullName = "global::System." + symbol.Name; } else { fullName = symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat); } NameSyntax replacement = SyntaxFactory.ParseName(fullName); if (!originalName.DescendantNodesAndSelf().OfType<AliasQualifiedNameSyntax>().Any()) { replacement = replacement.ReplaceNodes( replacement.DescendantNodesAndSelf().OfType<AliasQualifiedNameSyntax>(), (originalNode2, rewrittenNode2) => rewrittenNode2.Name); } rewrittenName = replacement.WithTriviaFrom(originalName); break; } else { rewrittenName = originalName; break; } } else { rewrittenName = originalName; break; } case SyntaxKind.AliasQualifiedName: case SyntaxKind.PredefinedType: default: rewrittenName = originalName; break; } if (rewrittenName == originalName) { return usingDirective; } return usingDirective.ReplaceNode(originalName, rewrittenName); }
public NamespaceOrTypeAndUsingDirective(NamespaceOrTypeSymbol namespaceOrType, UsingDirectiveSyntax usingDirective) { this.NamespaceOrType = namespaceOrType; this.UsingDirective = usingDirective; }
private bool IsSeparatedSystemUsing(UsingDirectiveSyntax syntax) { if (!this.separateSystemDirectives) { return false; } return syntax.Alias == null && syntax.IsSystemUsingDirective() && !syntax.HasNamespaceAliasQualifier() && syntax.StaticKeyword.IsKind(SyntaxKind.None); }
public override void VisitUsingDirective(UsingDirectiveSyntax node) { // base.VisitUsingDirective(node); }
public override SyntaxNode VisitUsingDirective(UsingDirectiveSyntax node) { // The strip list is used to remove using directives that will be moved. if (this.stripList.Contains(node)) { var nextToken = node.SemicolonToken.GetNextToken(); if (!nextToken.IsKind(SyntaxKind.None)) { var index = TriviaHelper.IndexOfFirstNonBlankLineTrivia(nextToken.LeadingTrivia); if (index != 0) { this.tokensToStrip.AddLast(nextToken); } } return null; } // The replacement map is used to replace using declarations in place in sorted order (inside directive trivia) UsingDirectiveSyntax replacementNode; if (this.replaceMap.TryGetValue(node, out replacementNode)) { return replacementNode; } return base.VisitUsingDirective(node); }
private static int CompareSpanStart(UsingDirectiveSyntax left, UsingDirectiveSyntax right) { return(left.SpanStart - right.SpanStart); }
public override SyntaxNode VisitUsingDirective(UsingDirectiveSyntax node) { return null; }
private UsingDirectiveSyntax QualifyUsingDirective(UsingDirectiveSyntax usingDirective) { NameSyntax originalName = usingDirective.Name; NameSyntax rewrittenName; switch (originalName.Kind()) { case SyntaxKind.QualifiedName: case SyntaxKind.IdentifierName: case SyntaxKind.GenericName: if (originalName.Parent.IsKind(SyntaxKind.UsingDirective) || originalName.Parent.IsKind(SyntaxKind.TypeArgumentList)) { var symbol = this.semanticModel.GetSymbolInfo(originalName, cancellationToken: CancellationToken.None).Symbol; if (symbol == null) { rewrittenName = originalName; break; } if (symbol is INamespaceSymbol) { // TODO: Preserve inner trivia string fullName = symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat); NameSyntax replacement = SyntaxFactory.ParseName(fullName); if (!originalName.DescendantNodesAndSelf().OfType <AliasQualifiedNameSyntax>().Any()) { replacement = replacement.ReplaceNodes( replacement.DescendantNodesAndSelf().OfType <AliasQualifiedNameSyntax>(), (originalNode2, rewrittenNode2) => rewrittenNode2.Name); } rewrittenName = replacement.WithTriviaFrom(originalName); break; } else if (symbol is INamedTypeSymbol) { // TODO: Preserve inner trivia // TODO: simplify after qualification string fullName; if (SpecialTypeHelper.IsPredefinedType(((INamedTypeSymbol)symbol).OriginalDefinition.SpecialType)) { fullName = "global::System." + symbol.Name; } else { fullName = symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat); } NameSyntax replacement = SyntaxFactory.ParseName(fullName); if (!originalName.DescendantNodesAndSelf().OfType <AliasQualifiedNameSyntax>().Any()) { replacement = replacement.ReplaceNodes( replacement.DescendantNodesAndSelf().OfType <AliasQualifiedNameSyntax>(), (originalNode2, rewrittenNode2) => rewrittenNode2.Name); } rewrittenName = replacement.WithTriviaFrom(originalName); break; } else { rewrittenName = originalName; break; } } else { rewrittenName = originalName; break; } case SyntaxKind.AliasQualifiedName: case SyntaxKind.PredefinedType: default: rewrittenName = originalName; break; } if (rewrittenName == originalName) { return(usingDirective); } return(usingDirective.ReplaceNode(originalName, rewrittenName)); }
/// <summary> /// Given a using declaration get the corresponding symbol for the using alias that was introduced. /// </summary> /// <param name="declarationSyntax"></param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The alias symbol that was declared.</returns> /// <remarks> /// If the using directive is an error because it attempts to introduce an alias for which an existing alias was /// previously declared in the same scope, the result is a newly-constructed AliasSymbol (i.e. not one from the /// symbol table). /// </remarks> public override IAliasSymbol GetDeclaredSymbol( UsingDirectiveSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken)) { CheckSyntaxNode(declarationSyntax); if (declarationSyntax.Alias == null) { return null; } InContainerBinder binder = _binderFactory.GetImportsBinder(declarationSyntax.Parent); var imports = binder.GetImports(basesBeingResolved: null); var alias = imports.UsingAliases[declarationSyntax.Alias.Name.Identifier.ValueText]; if ((object)alias.Alias == null) { // Case: no aliases return null; } else if (alias.Alias.Locations[0].SourceSpan == declarationSyntax.Alias.Name.Span) { // Case: first alias (there may be others) return alias.Alias; } else { // Case: multiple aliases, not the first (see DevDiv #9368) return new AliasSymbol(binder, declarationSyntax); } }
public override SyntaxNode VisitUsingDirective(UsingDirectiveSyntax node) { node = (UsingDirectiveSyntax)base.VisitUsingDirective(node); Classes.Add(node); return(node); }
/// <summary>Called when the visitor visits a UsingDirectiveSyntax node.</summary> public override SyntaxNode VisitUsingDirective(UsingDirectiveSyntax node) { var r = base.VisitUsingDirective(node); return(r.WithTrailingTrivia(Tabs.BrTabs())); }
public static bool IsNUnitUsing(this UsingDirectiveSyntax node) => node.Name.ToString() == "NUnit.Framework";
internal void RecordImport(UsingDirectiveSyntax syntax) { RecordImportInternal(syntax); }
public override void VisitUsingDirective(UsingDirectiveSyntax node) { _usings.Add(node); }