public override SyntaxNode VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { if (node == null) return null; var symbol = _semanticModel.GetDeclaredSymbol(node); node = (ConversionOperatorDeclarationSyntax)base.VisitConversionOperatorDeclaration(node); if (!IsPrivateOrInternal(symbol.DeclaredAccessibility)) node = (ConversionOperatorDeclarationSyntax)ApplyDocComment(node, symbol.GetDocumentationCommentId()); return node; }
private static async Task<Document> ReplaceWithExpressionBodiedMember(Document document, ConversionOperatorDeclarationSyntax declaration, CancellationToken cancellationToken) { var newDeclaration = declaration .WithExpressionBody(SyntaxFactory.ArrowExpressionClause(GetExpression(declaration.Body))) .WithBody(null) .WithSemicolonToken(GetSemicolon(declaration.Body)) .WithAdditionalAnnotations(Formatter.Annotation); var root = await document.GetSyntaxRootAsync(cancellationToken); var newRoot = root.ReplaceNode(declaration, newDeclaration); return document.WithSyntaxRoot(newRoot); }
public static SourceUserDefinedConversionSymbol CreateUserDefinedConversionSymbol( SourceMemberContainerTypeSymbol containingType, ConversionOperatorDeclarationSyntax syntax, DiagnosticBag diagnostics) { // Dev11 includes the explicit/implicit keyword, but we don't have a good way to include // Narrowing/Widening in VB and we want the languages to be consistent. var location = syntax.Type.Location; string name = syntax.ImplicitOrExplicitKeyword.IsKind(SyntaxKind.ImplicitKeyword) ? WellKnownMemberNames.ImplicitConversionName : WellKnownMemberNames.ExplicitConversionName; return new SourceUserDefinedConversionSymbol( containingType, name, location, syntax, diagnostics); }
// NOTE: no need to call WithUnsafeRegionIfNecessary, since the signature // is bound lazily using binders from a BinderFactory (which will already include an // UnsafeBinder, if necessary). private SourceUserDefinedConversionSymbol( SourceMemberContainerTypeSymbol containingType, string name, Location location, ConversionOperatorDeclarationSyntax syntax, DiagnosticBag diagnostics) : base( MethodKind.Conversion, name, containingType, location, syntax.GetReference(), syntax.Body.GetReferenceOrNull(), syntax.Modifiers, diagnostics) { }
public static void Go(OutputWriter writer, ConversionOperatorDeclarationSyntax method) { //TODO: Need to find a way of dealing with this ... Quickly moving towards the idea of compile/decompile using ILSPY // if (method.ImplicitOrExplicitKeyword.RawKind != (decimal) SyntaxKind.ExplicitKeyword) // throw new Exception("Implicit cast operators are not supported " + Utility.Descriptor(method)); var temp = new TempWriter(); // temp.WriteIndent(); temp.Write("public static " + TypeProcessor.ConvertType(method.Type)); temp.Write(" " + ((method.ImplicitOrExplicitKeyword.RawKind != (decimal) SyntaxKind.ExplicitKeyword) ? ("op_Implicit_" + TypeProcessor.ConvertType(method.Type,false,true,false).Replace(".", "_")) : "op_Explicit")); //writer.Write(" op_Explicit"); // writer.Write(TypeProcessor.ConvertType(method.Type)); temp.Write("("); bool firstParam = true; foreach (var param in method.ParameterList.Parameters) { if (firstParam) firstParam = false; else temp.Write(", "); temp.Write(TypeProcessor.ConvertType(param.Type) + " "); temp.Write(WriteIdentifierName.TransformIdentifier(param.Identifier.Text)); } temp.Write(")"); writer.WriteLine(temp.ToString()); writer.OpenBrace(); foreach (var statement in method.Body.Statements) Core.Write(writer, statement); writer.CloseBrace(); }
private static ConversionOperatorDeclarationSyntax UseExpressionBodyIfDesired( Workspace workspace, ConversionOperatorDeclarationSyntax declaration, ParseOptions options) { if (declaration.ExpressionBody == null) { var preferExpressionBody = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators).Value; if (preferExpressionBody) { var expressionBody = declaration.Body.TryConvertToExpressionBody(options); if (expressionBody != null) { return declaration.WithBody(null) .WithExpressionBody(expressionBody) .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); } } } return declaration; }
public override SyntaxNode VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { this.AppendCompileIssue(node, IssueType.Error, IssueId.ConverterOperatorNotSupport); return node; }
protected override (TypeWithAnnotations ReturnType, ImmutableArray <ParameterSymbol> Parameters) MakeParametersAndBindReturnType(BindingDiagnosticBag diagnostics) { ConversionOperatorDeclarationSyntax declarationSyntax = GetSyntax(); return(MakeParametersAndBindReturnType(declarationSyntax, declarationSyntax.Type, diagnostics)); }
/// <summary> /// Creates a new <see cref="Syntax.ModifierListInfo"/> from the specified conversion operator declaration. /// </summary> /// <param name="conversionOperatorDeclaration"></param> /// <returns></returns> public static ModifierListInfo ModifierListInfo(ConversionOperatorDeclarationSyntax conversionOperatorDeclaration) { return(Syntax.ModifierListInfo.Create(conversionOperatorDeclaration)); }
public static bool CanRefactor(ConversionOperatorDeclarationSyntax operatorDeclaration, TextSpan?span = null) { return(operatorDeclaration.Body != null && span?.IsEmptyAndContainedInSpanOrBetweenSpans(operatorDeclaration.Body) != false && UseExpressionBodiedMemberAnalysis.GetReturnExpression(operatorDeclaration.Body) != null); }
public override void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { Visit(node.Body); Visit(node.ExpressionBody); }
public override SyntaxNode VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { return(Apply(base.VisitConversionOperatorDeclaration(node))); }
public ConversionOperatorDeclarationTranslation(ConversionOperatorDeclarationSyntax syntax, SyntaxTranslation parent) : base(syntax, parent) { Type = syntax.Type.Get <TypeTranslation>(this); }
private static Func <CancellationToken, Task <Document> > GetCreateChangedDocument(CodeFixContext context, SyntaxNode node) { switch (node.Kind()) { case SyntaxKind.MethodDeclaration: { var methodDeclaration = (MethodDeclarationSyntax)node; SyntaxToken semicolonToken = methodDeclaration.SemicolonToken; if (semicolonToken.Kind() == SyntaxKind.None) { break; } ParameterListSyntax parameterList = methodDeclaration.ParameterList; if (parameterList == null) { break; } return(cancellationToken => { MethodDeclarationSyntax newNode = methodDeclaration .WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetAllTrivia())) .WithSemicolonToken(default(SyntaxToken)) .WithBody(Block()) .WithFormatterAnnotation(); return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken); }); } case SyntaxKind.ConstructorDeclaration: { var constructorDeclaration = (ConstructorDeclarationSyntax)node; SyntaxToken semicolonToken = constructorDeclaration.SemicolonToken; if (semicolonToken.Kind() == SyntaxKind.None) { break; } ParameterListSyntax parameterList = constructorDeclaration.ParameterList; if (parameterList == null) { break; } return(cancellationToken => { ConstructorDeclarationSyntax newNode = constructorDeclaration .WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetAllTrivia())) .WithSemicolonToken(default(SyntaxToken)) .WithBody(Block()) .WithFormatterAnnotation(); return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken); }); } case SyntaxKind.DestructorDeclaration: { var destructorDeclaration = (DestructorDeclarationSyntax)node; SyntaxToken semicolonToken = destructorDeclaration.SemicolonToken; if (semicolonToken.Kind() == SyntaxKind.None) { break; } ParameterListSyntax parameterList = destructorDeclaration.ParameterList; if (parameterList == null) { break; } return(cancellationToken => { DestructorDeclarationSyntax newNode = destructorDeclaration .WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetAllTrivia())) .WithSemicolonToken(default(SyntaxToken)) .WithBody(Block()) .WithFormatterAnnotation(); return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken); }); } case SyntaxKind.OperatorDeclaration: { var operatorDeclaration = (OperatorDeclarationSyntax)node; SyntaxToken semicolonToken = operatorDeclaration.SemicolonToken; if (semicolonToken.Kind() == SyntaxKind.None) { break; } ParameterListSyntax parameterList = operatorDeclaration.ParameterList; if (parameterList == null) { break; } return(cancellationToken => { OperatorDeclarationSyntax newNode = operatorDeclaration .WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetAllTrivia())) .WithSemicolonToken(default(SyntaxToken)) .WithBody(Block()) .WithFormatterAnnotation(); return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken); }); } case SyntaxKind.ConversionOperatorDeclaration: { var conversionOperatorDeclaration = (ConversionOperatorDeclarationSyntax)node; SyntaxToken semicolonToken = conversionOperatorDeclaration.SemicolonToken; if (semicolonToken.Kind() == SyntaxKind.None) { break; } ParameterListSyntax parameterList = conversionOperatorDeclaration.ParameterList; if (parameterList == null) { break; } return(cancellationToken => { ConversionOperatorDeclarationSyntax newNode = conversionOperatorDeclaration .WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetAllTrivia())) .WithSemicolonToken(default(SyntaxToken)) .WithBody(Block()) .WithFormatterAnnotation(); return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken); }); } case SyntaxKind.GetAccessorDeclaration: case SyntaxKind.SetAccessorDeclaration: { var accessorDeclaration = (AccessorDeclarationSyntax)node; SyntaxToken semicolonToken = accessorDeclaration.SemicolonToken; if (semicolonToken.Kind() == SyntaxKind.None) { break; } return(cancellationToken => { AccessorDeclarationSyntax newNode = accessorDeclaration .WithSemicolonToken(default(SyntaxToken)) .WithBody(Block( Token(default(SyntaxTriviaList), SyntaxKind.OpenBraceToken, TriviaList(ElasticSpace)), default(SyntaxList <StatementSyntax>), Token(default(SyntaxTriviaList), SyntaxKind.CloseBraceToken, semicolonToken.LeadingAndTrailingTrivia()))); SyntaxToken keyword = newNode.Keyword; if (!keyword.HasTrailingTrivia) { newNode = newNode.WithKeyword(keyword.WithTrailingTrivia(ElasticSpace)); } return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken); }); } case SyntaxKind.LocalFunctionStatement: { var localFunction = (LocalFunctionStatementSyntax)node; SyntaxToken semicolonToken = localFunction.SemicolonToken; if (semicolonToken.Kind() == SyntaxKind.None) { break; } ParameterListSyntax parameterList = localFunction.ParameterList; if (parameterList == null) { break; } return(cancellationToken => { LocalFunctionStatementSyntax newNode = localFunction .WithParameterList(parameterList.AppendToTrailingTrivia(semicolonToken.GetAllTrivia())) .WithSemicolonToken(default(SyntaxToken)) .WithBody(Block()) .WithFormatterAnnotation(); return context.Document.ReplaceNodeAsync(node, newNode, cancellationToken); }); } } Debug.Fail(node.Kind().ToString()); return(null); }
public override void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { throw new NotImplementedException(); }
public void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { if (node == null) throw new ArgumentNullException("node"); node.Validate(); WriteLeadingTrivia(node); _writer.WriteIndent(); WriteAttributes( node, _writer.Configuration.LineBreaksAndWrapping.Other.PlaceMethodAttributeOnSameLine ); WriteMemberModifiers(node.Modifiers); _writer.WriteKeyword(node.Kind == ImplicitOrExplicit.Explicit ? PrinterKeyword.Explicit : PrinterKeyword.Implicit); _writer.WriteSpace(); _writer.WriteKeyword(PrinterKeyword.Operator); _writer.WriteSpace(); node.Type.Accept(this); node.ParameterList.Accept(this); node.Body.Accept(this); WriteTrailingTrivia(node); }
public TameConversionOperatorDeclarationSyntax(ConversionOperatorDeclarationSyntax node) { Node = node; AddChildren(); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { this.OnNodeVisited(node); if (!this.traverseRootOnly) base.VisitConversionOperatorDeclaration(node); }
public sealed override SyntaxNode VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) => VisitMethodImpl(node);
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { this.OnNodeVisited(node, this.type.IsInstanceOfType(node)); base.VisitConversionOperatorDeclaration(node); }
public override void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { VisitBlock(node.Body); }
public override void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { base.VisitConversionOperatorDeclaration(node); }
private static string InternalGetNodeName(ConversionOperatorDeclarationSyntax node) => "Conversion-" + node.Type + "-from-" + string.Join("-", node.ParameterList.Parameters.Select(p => p.Type));
public override void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { // TODO: implement this }
public override void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { visitMethod <ConversionOperatorDeclarationSyntax>(node, base.VisitConversionOperatorDeclaration); }
public override SyntaxNode VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { node = (ConversionOperatorDeclarationSyntax)base.VisitConversionOperatorDeclaration(node); Classes.Add(node); return(node); }
private static async Task<Document> ReplaceWithExpressionBodiedMember(Document document, ConversionOperatorDeclarationSyntax declaration, CancellationToken cancellationToken) { SyntaxTriviaList leadingTrivia; var expression = GetExpressionAndLeadingTrivia(declaration.Body, out leadingTrivia); var declarationTrivia = declaration.GetLeadingTrivia(); declarationTrivia = declarationTrivia.AddRange(leadingTrivia); var newDeclaration = declaration .WithLeadingTrivia(declarationTrivia) .WithExpressionBody(SyntaxFactory.ArrowExpressionClause(expression)) .WithBody(null) .WithSemicolonToken(GetSemicolon(declaration.Body)) .WithAdditionalAnnotations(Formatter.Annotation); var root = await document.GetSyntaxRootAsync(cancellationToken); var newRoot = root.ReplaceNode(declaration, newDeclaration); return document.WithSyntaxRoot(newRoot); }
public ConversionOperatorDeclarationTranslation(ConversionOperatorDeclarationSyntax syntax, SyntaxTranslation parent) : base(syntax, parent) { Type = syntax.Type.Get<TypeTranslation>(this); }
public override LuaSyntaxNode VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { BuildOperatorMethodDeclaration(node); return(base.VisitConversionOperatorDeclaration(node)); }
public override void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { IMethodSymbol declSym = m_Model.GetDeclaredSymbol(node); VisitCommonMethodDeclaration(declSym, node, node.Body, node.ExpressionBody); }
private async Task<Document> HandleConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax declaration, Document document, CancellationToken cancellationToken) { var returnStatement = SyntaxFactory.ReturnStatement( returnKeyword: SyntaxFactory.Token(SyntaxKind.ReturnKeyword), expression: declaration.ExpressionBody.Expression, semicolonToken: declaration.SemicolonToken); var newDeclaration = declaration .WithBody(SyntaxFactory.Block(returnStatement)) .WithExpressionBody(null) .WithSemicolonToken(default(SyntaxToken)) .WithAdditionalAnnotations(Formatter.Annotation); var oldRoot = await document.GetSyntaxRootAsync(cancellationToken); var newRoot = oldRoot.ReplaceNode(declaration, newDeclaration); return document.WithSyntaxRoot(newRoot); }
public static string OperatorNameFromDeclaration(ConversionOperatorDeclarationSyntax declaration) { return(OperatorNameFromDeclaration((Syntax.InternalSyntax.ConversionOperatorDeclarationSyntax)(declaration.Green))); }
public override void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { VisitMethod(node); }
public override void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { LogicalLineCount++; base.VisitConversionOperatorDeclaration(node); }
// Returns the name of the declared API if the node is the type of node that should have an XML doc comment // otherwise returns null; public string GetAPIForNode(SyntaxNode node) { switch (node.Kind()) { case SyntaxKind.ConstructorDeclaration: { ConstructorDeclarationSyntax syntax = (ConstructorDeclarationSyntax)node; // assume only one field/identifier string text = syntax.Identifier.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.ConversionOperatorDeclaration: { ConversionOperatorDeclarationSyntax syntax = (ConversionOperatorDeclarationSyntax)node; // assume only one field/identifier string text = syntax.OperatorKeyword.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.DelegateDeclaration: { DelegateDeclarationSyntax syntax = (DelegateDeclarationSyntax)node; // assume only one field/identifier string text = syntax.Identifier.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.EnumDeclaration: { EnumDeclarationSyntax syntax = (EnumDeclarationSyntax)node; // assume only one field/identifier string text = syntax.Identifier.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.EventDeclaration: { /* EventDeclarationSyntax syntax = (EventDeclarationSyntax)node; * * string text = syntax.Identifier.Text; * // for now assume only one match * if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) * { * var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); * // but which one is the right one? * var symbol = symbols.Single(); * return symbol.GetDocumentationCommentId(); * }*/ return(null); } case SyntaxKind.FieldDeclaration: { FieldDeclarationSyntax syntax = (FieldDeclarationSyntax)node; // assume only one field/identifier string text = syntax.Declaration.Variables.First().Identifier.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.IndexerDeclaration: { IndexerDeclarationSyntax syntax = (IndexerDeclarationSyntax)node; string text = syntax.ThisKeyword.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.InterfaceDeclaration: { InterfaceDeclarationSyntax syntax = (InterfaceDeclarationSyntax)node; string text = syntax.Identifier.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.MethodDeclaration: { MethodDeclarationSyntax methodDeclarationSyntax = (MethodDeclarationSyntax)node; string text = methodDeclarationSyntax.Identifier.Text; var parameters = methodDeclarationSyntax.ParameterList.Parameters; if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // select the symbol whose declaring syntax reference matches the node's syntax reference. //var symbol = symbols.Where(s => s.DeclaringSyntaxReferences.Contains(node.GetReference())).Single(); foreach (var symbol in symbols) { var references = symbol.DeclaringSyntaxReferences; foreach (var reference in references) { SyntaxNode testNode = reference.GetSyntax(); if (testNode.Equals(node)) { Console.WriteLine("Matched nodes."); } } } // find the one that corresponds to this syntax node. //foreach (var symbol in symbols) //{ // IMethodSymbol methodsymbol = (IMethodSymbol)symbol; // symbol.DeclaringSyntaxReferences.Select(syntaxReference => syntaxReference == node.GetReference()); // //} return(symbols.First().GetDocumentationCommentId()); } return(null); } case SyntaxKind.NamespaceDeclaration: // doesn't work { NamespaceDeclarationSyntax syntax = (NamespaceDeclarationSyntax)node; NameSyntax nameSyntax = syntax.Name; string text = nameSyntax.ToFullString(); // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.OperatorDeclaration: { OperatorDeclarationSyntax syntax = (OperatorDeclarationSyntax)node; // this won't work, it needs to be figured out. string text = syntax.OperatorKeyword.Text + syntax.OperatorToken.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.PropertyDeclaration: { PropertyDeclarationSyntax syntax = (PropertyDeclarationSyntax)node; string text = syntax.Identifier.Text; // for now assume only one match if (m_compilation.ContainsSymbolsWithName(symbolName => symbolName == text)) { var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } return(null); } case SyntaxKind.ClassDeclaration: { Microsoft.CodeAnalysis.CSharp.Syntax.ClassDeclarationSyntax classSyntax = (ClassDeclarationSyntax)node; string text = classSyntax.Identifier.Text; string valueText = classSyntax.Identifier.ValueText; // for now assume only one match var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } case SyntaxKind.StructDeclaration: { Microsoft.CodeAnalysis.CSharp.Syntax.StructDeclarationSyntax structSyntax = (StructDeclarationSyntax)node; string text = structSyntax.Identifier.Text; string valueText = structSyntax.Identifier.ValueText; // for now assume only one match var symbols = m_compilation.GetSymbolsWithName(symbolName => symbolName == text); // but which one is the right one? var symbol = symbols.Single(); return(symbol.GetDocumentationCommentId()); } default: return(null); } //var types = m_compilation.GlobalNamespace.GetTypeMembers(name); //m_compilation.GetTypeByMetadataName() //string docCommentId = classSymbol.GetDocumentationCommentId(); return(""); }
public override void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) => VisitBaseMethodDeclaration(node);
//public override void VisitConstructorInitializer(ConstructorInitializerSyntax node) //{ // base.VisitConstructorInitializer(node); //} //public override void VisitContinueStatement(ContinueStatementSyntax node) //{ // base.VisitContinueStatement(node); //} public override void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { VisitBodyOrExpressionBody(node.Body, node.ExpressionBody); //base.VisitConversionOperatorDeclaration(node); }
public static bool CanRefactor(ConversionOperatorDeclarationSyntax operatorDeclaration, TextSpan?span = null) { return(operatorDeclaration.Body != null && span?.IsEmptyAndContainedInSpanOrBetweenSpans(operatorDeclaration.Body) != false && BlockExpressionAnalysis.SupportsExpressionBody(operatorDeclaration.Body, allowExpressionStatement: false)); }
/// <summary> /// Creates a new <see cref="ModifierListInfo"/> with the specified modifiers updated. /// </summary> /// <param name="modifiers"></param> /// <returns></returns> public ModifierListInfo WithModifiers(SyntaxTokenList modifiers) { ThrowInvalidOperationIfNotInitialized(); switch (Parent.Kind()) { case SyntaxKind.ClassDeclaration: { var classDeclaration = (ClassDeclarationSyntax)Parent; ClassDeclarationSyntax newNode = classDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.ConstructorDeclaration: { var constructorDeclaration = (ConstructorDeclarationSyntax)Parent; ConstructorDeclarationSyntax newNode = constructorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.OperatorDeclaration: { var operatorDeclaration = (OperatorDeclarationSyntax)Parent; OperatorDeclarationSyntax newNode = operatorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.ConversionOperatorDeclaration: { var conversionOperatorDeclaration = (ConversionOperatorDeclarationSyntax)Parent; ConversionOperatorDeclarationSyntax newNode = conversionOperatorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.DelegateDeclaration: { var delegateDeclaration = (DelegateDeclarationSyntax)Parent; DelegateDeclarationSyntax newNode = delegateDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.DestructorDeclaration: { var destructorDeclaration = (DestructorDeclarationSyntax)Parent; DestructorDeclarationSyntax newNode = destructorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.EnumDeclaration: { var enumDeclaration = (EnumDeclarationSyntax)Parent; EnumDeclarationSyntax newNode = enumDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.EventDeclaration: { var eventDeclaration = (EventDeclarationSyntax)Parent; EventDeclarationSyntax newNode = eventDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.EventFieldDeclaration: { var eventFieldDeclaration = (EventFieldDeclarationSyntax)Parent; EventFieldDeclarationSyntax newNode = eventFieldDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.FieldDeclaration: { var fieldDeclaration = (FieldDeclarationSyntax)Parent; FieldDeclarationSyntax newNode = fieldDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.IndexerDeclaration: { var indexerDeclaration = (IndexerDeclarationSyntax)Parent; IndexerDeclarationSyntax newNode = indexerDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.InterfaceDeclaration: { var interfaceDeclaration = (InterfaceDeclarationSyntax)Parent; InterfaceDeclarationSyntax newNode = interfaceDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.MethodDeclaration: { var methodDeclaration = (MethodDeclarationSyntax)Parent; MethodDeclarationSyntax newNode = methodDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.PropertyDeclaration: { var propertyDeclaration = (PropertyDeclarationSyntax)Parent; PropertyDeclarationSyntax newNode = propertyDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.StructDeclaration: { var structDeclaration = (StructDeclarationSyntax)Parent; StructDeclarationSyntax newNode = structDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.IncompleteMember: { var incompleteMember = (IncompleteMemberSyntax)Parent; IncompleteMemberSyntax newNode = incompleteMember.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.GetAccessorDeclaration: case SyntaxKind.SetAccessorDeclaration: case SyntaxKind.AddAccessorDeclaration: case SyntaxKind.RemoveAccessorDeclaration: case SyntaxKind.UnknownAccessorDeclaration: { var accessorDeclaration = (AccessorDeclarationSyntax)Parent; AccessorDeclarationSyntax newNode = accessorDeclaration.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.LocalDeclarationStatement: { var localDeclarationStatement = (LocalDeclarationStatementSyntax)Parent; LocalDeclarationStatementSyntax newNode = localDeclarationStatement.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.LocalFunctionStatement: { var localFunctionStatement = (LocalFunctionStatementSyntax)Parent; LocalFunctionStatementSyntax newNode = localFunctionStatement.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } case SyntaxKind.Parameter: { var parameter = (ParameterSyntax)Parent; ParameterSyntax newNode = parameter.WithModifiers(modifiers); return(new ModifierListInfo(newNode, newNode.Modifiers)); } } throw new InvalidOperationException(); }
internal static ParameterInfo ParameterInfo( ConversionOperatorDeclarationSyntax conversionOperatorDeclaration, bool allowMissing = false) { return(Syntax.ParameterInfo.Create(conversionOperatorDeclaration, allowMissing)); }
public override SyntaxNode VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { this.AppendCompileIssue(node, IssueType.Error, IssueId.ConverterOperatorNotSupport); return(node); }
private static SyntaxNode HandleConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { SyntaxToken triviaToken = node.ImplicitOrExplicitKeyword; if (triviaToken.IsMissing) { return null; } SyntaxTokenList modifiers = DeclarationModifiersHelper.AddModifier(node.Modifiers, ref triviaToken, SyntaxKind.PublicKeyword); return node .WithImplicitOrExplicitKeyword(triviaToken) .WithModifiers(modifiers) .WithoutFormatting(); }
public static bool CanRefactor(ConversionOperatorDeclarationSyntax declaration, SemanticModel semanticModel, CancellationToken cancellationToken = default(CancellationToken)) { return(CanRefactor(declaration.Type, semanticModel, cancellationToken)); }
private void ClassifyUpdate(ConversionOperatorDeclarationSyntax oldNode, ConversionOperatorDeclarationSyntax newNode) { if (!SyntaxFactory.AreEquivalent(oldNode.Modifiers, newNode.Modifiers)) { ReportError(RudeEditKind.ModifiersUpdate); return; } if (!SyntaxFactory.AreEquivalent(oldNode.ImplicitOrExplicitKeyword, newNode.ImplicitOrExplicitKeyword)) { ReportError(RudeEditKind.Renamed); return; } if (!SyntaxFactory.AreEquivalent(oldNode.Type, newNode.Type)) { ReportError(RudeEditKind.TypeUpdate); return; } ClassifyMethodBodyRudeUpdate( (SyntaxNode)oldNode.Body ?? oldNode.ExpressionBody?.Expression, (SyntaxNode)newNode.Body ?? newNode.ExpressionBody?.Expression, containingMethodOpt: null, containingType: (TypeDeclarationSyntax)newNode.Parent); }
public override TypeWithNode VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node) { return(HandleMethodDeclaration(node)); }