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 void VisitConversionOperatorDeclaration(ConversionOperatorDeclarationSyntax node)
{
VisitBlock(node.Body);
}
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));
}
