public override void VisitClassDeclaration(ClassDeclarationSyntax node)
{
var symbol = model.GetDeclaredSymbol(node);
VisitDeclaration(symbol, node.Span);
base.VisitClassDeclaration(node);
}
protected override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
var newTypeDeclaration = (TypeDeclarationSyntax)base.VisitClassDeclaration(node);
if (_fields.Count > 0 || _methods.Count > 0)
{
var members = new List<MemberDeclarationSyntax>(newTypeDeclaration.Members);
members.InsertRange(0, _methods);
members.InsertRange(0, _fields);
return ((ClassDeclarationSyntax)newTypeDeclaration).Update(
newTypeDeclaration.Attributes,
newTypeDeclaration.Modifiers,
newTypeDeclaration.Keyword,
newTypeDeclaration.Identifier,
newTypeDeclaration.TypeParameterListOpt,
newTypeDeclaration.BaseListOpt,
newTypeDeclaration.ConstraintClauses,
newTypeDeclaration.OpenBraceToken,
Syntax.List(members.AsEnumerable()),
newTypeDeclaration.CloseBraceToken,
newTypeDeclaration.SemicolonTokenOpt);
}
return newTypeDeclaration;
}
private ClassDeclarationSyntax MoveField(ClassDeclarationSyntax node)
{
//SyntaxList is immutable, so we need a regular list of members, to add our field to
var list=node.Members.ToList<MemberDeclarationSyntax>();
//change visibility to protected so that it can still be used in child classes
var field = fds.Update(fds.Attributes,
Syntax.TokenList(Syntax.Token(SyntaxKind.ProtectedKeyword)),
fds.Declaration,
fds.SemicolonToken);
//add field as the first member in the parent class
list.Insert(0,field);
//if a property for the field exists, move it to parent class as well
if (prop!=null)
list.Add(prop);
//make a SyntaxList out of the list
var syntaxlist = Syntax.List<MemberDeclarationSyntax>(list.ToArray<MemberDeclarationSyntax>());
//"update" the class node - create another syntax tree with a changed node
var newclass= node.Update( node.Attributes,
node.Modifiers,
node.Keyword,
node.Identifier,
node.TypeParameterListOpt,
node.BaseListOpt,
node.ConstraintClauses,
node.OpenBraceToken,
syntaxlist,
node.CloseBraceToken,
node.SemicolonTokenOpt);
return newclass;
}
/// <summary>
/// Checks if any property in the class given as parameter has a getter for the field we are moving.
/// </summary>
/// <param name="node">Syntax node of the class the field belongs to.</param>
/// <param name="semanticModel">Semantic model for the code we are processing.</param>
/// <returns></returns>
private PropertyDeclarationSyntax getProperty(ClassDeclarationSyntax node, SemanticModel semanticModel)
{
foreach (var p in node.Members.Where(m => m.Kind == SyntaxKind.PropertyDeclaration))
{
var property = p as PropertyDeclarationSyntax;
var accessors = property.AccessorList.Accessors;
var getter = accessors.FirstOrDefault(ad => ad.Kind == SyntaxKind.GetAccessorDeclaration);
var statements = getter.BodyOpt.Statements;
if (statements.Count != 0)
{
var returnStatement = statements.FirstOrDefault() as ReturnStatementSyntax;
if (returnStatement != null && returnStatement.ExpressionOpt != null)
{
var semanticInfo = document.GetSemanticModel().GetSemanticInfo(returnStatement.ExpressionOpt);
var fieldSymbol = semanticInfo.Symbol as FieldSymbol;
if (fieldSymbol != null && fieldSymbol == semanticModel.GetDeclaredSymbol(field))
{
return property;
}
}
}
}
return null;
}
public override void VisitClassDeclaration(ClassDeclarationSyntax node)
{
if (node.Attributes.Any(a => a.DescendantNodes().OfType<AttributeSyntax>().Any(s => s.Name.GetText() == typeof(JavaScript).Name)))
Classes.Add(node);
base.VisitClassDeclaration(node);
}
public ClassInfo GetClassInfo(ClassDeclarationSyntax classDeclaration)
{
_walker.Visit(classDeclaration);
ClassInfo classInfo = new ClassInfo(classDeclaration, _semanticModel, _semanticModel.GetDeclaredSymbol(classDeclaration));
classInfo.Locks.AddRange(_walker.Locks);
classInfo.GuardedFields.AddRange(_walker.GuardedFields);
classInfo.Members.AddRange(_walker.Members);
foreach (LockInfo lockInfo in classInfo.Locks)
{
lockInfo.Parent = classInfo;
}
foreach (GuardedFieldInfo fieldInfo in classInfo.GuardedFields)
{
fieldInfo.Parent = classInfo;
}
foreach (MemberInfo memberInfo in classInfo.Members)
{
memberInfo.Parent = classInfo;
}
return classInfo;
}
public FieldMover(SemanticModel semanticModel, Symbol symbol, FieldDeclarationSyntax fds, PropertyDeclarationSyntax prop, ClassDeclarationSyntax parent)
{
this.semanticModel = semanticModel;
this.parent = parent;
this.fieldSymbol = symbol;
this.fds = fds;
this.prop = prop;
}
public CallGraphTest()
{
source = FileUtil.ReadAllText(path);
tree = ASTUtil.GetSyntaxTreeFromSource(source);
classDeclaration = tree.GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>().
First(c => c.Identifier.Value.Equals("CallGraphTest"));
graph = new CallGraphBuilder(classDeclaration, tree).BuildCallGraph();
}
protected override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
if (node == parent)
{
//show a pop-up with how the refactoring will look
return CodeActionAnnotations.FormattingAnnotation.AddAnnotationTo(
MoveField(node));
}
return base.VisitClassDeclaration(node);
}
public CodeAction(ICodeActionEditFactory editFactory, IDocument document, FieldDeclarationSyntax member, ClassDeclarationSyntax parent)
{
this.editFactory = editFactory;
this.document = document;
this.field = member;
this.parentClass = parent;
this.Description = "Move member to parent class";
this.Icon = null;
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
var visitClassDeclaration = (ClassDeclarationSyntax)base.VisitClassDeclaration(node);
visitClassDeclaration = visitClassDeclaration.AddMembers(delegateDeclarations.ToArray())
.AddMembers(methodDeclarations.ToArray());
var identifier = Syntax.Identifier(node.Identifier.ValueText + "Dynamic");
return visitClassDeclaration.WithIdentifier(identifier);
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
node = (ClassDeclarationSyntax)base.VisitClassDeclaration(node);
MethodDeclarationSyntax prector = Syntax.MethodDeclaration(Syntax.PredefinedType(Syntax.Token(SyntaxKind.VoidKeyword)), ".prector");
List<StatementSyntax> Initializers = new List<StatementSyntax>();
foreach (MemberDeclarationSyntax member in node.Members)
{
if (member.Kind == SyntaxKind.FieldDeclaration)
{
FieldDeclarationSyntax fds = (FieldDeclarationSyntax)member;
foreach (VariableDeclaratorSyntax vds in fds.Declaration.Variables)
{
if (vds.Initializer != null)
{
Initializers.Add(Syntax.ExpressionStatement(Syntax.BinaryExpression(SyntaxKind.AssignExpression, Syntax.IdentifierName(vds.Identifier), vds.Initializer.Value)));
}
}
}
}
if (Initializers.Count == 0)
return node;
int constructors = node.Members.Count((m) => (m is ConstructorDeclarationSyntax));
prector = prector.AddBodyStatements(Initializers.ToArray());
node = node.AddMembers(prector);
if (constructors == 0)
{
ConstructorDeclarationSyntax ctor = Syntax.ConstructorDeclaration(node.Identifier);
ctor = ctor.AddBodyStatements(Syntax.ExpressionStatement(Syntax.InvocationExpression(Syntax.IdentifierName(".prector"))));
ctor = ctor.AddModifiers(Syntax.Token(SyntaxKind.PublicKeyword));
return node.AddMembers(ctor);
}
SyntaxList<MemberDeclarationSyntax> newMembers = new SyntaxList<MemberDeclarationSyntax>();
foreach (MemberDeclarationSyntax member in node.Members)
{
if (member.Kind == SyntaxKind.ConstructorDeclaration)
{
newMembers = newMembers.Add((MemberDeclarationSyntax)ConstructorPrefixerDeclaration((ConstructorDeclarationSyntax)member));
}
else
{
newMembers = newMembers.Add(member);
}
}
return node.WithMembers(newMembers);
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
node = (ClassDeclarationSyntax)base.VisitClassDeclaration(node);
SyntaxList<MemberDeclarationSyntax> newMembers = new SyntaxList<MemberDeclarationSyntax>();
foreach (MemberDeclarationSyntax member in node.Members)
{
if (member.Kind == SyntaxKind.PropertyDeclaration)
{
PropertyDeclarationSyntax prop = (PropertyDeclarationSyntax)member;
SyntaxList<AccessorDeclarationSyntax> newAccessors = new SyntaxList<AccessorDeclarationSyntax>();
bool implementfield = false;
foreach (AccessorDeclarationSyntax accessor in prop.AccessorList.Accessors)
{
if (accessor.Body == null)
{
switch (accessor.Kind)
{
case SyntaxKind.GetAccessorDeclaration:
implementfield = true;
newAccessors = newAccessors.Add(accessor.WithBody(Syntax.Block(Syntax.ReturnStatement(Syntax.IdentifierName("_" + prop.Identifier.ValueText)))));
break;
case SyntaxKind.SetAccessorDeclaration:
implementfield = true;
newAccessors = newAccessors.Add(accessor.WithBody(Syntax.Block(Syntax.ExpressionStatement(Syntax.BinaryExpression(SyntaxKind.AssignExpression, Syntax.IdentifierName("_" + prop.Identifier.ValueText), Syntax.IdentifierName("value"))))));
break;
default:
newAccessors = newAccessors.Add(accessor);
break;
}
}
else
{
newAccessors = newAccessors.Add(accessor);
}
}
if (implementfield)
{
SeparatedSyntaxList<VariableDeclaratorSyntax> variables = new SeparatedSyntaxList<VariableDeclaratorSyntax>();
variables = variables.Add(Syntax.VariableDeclarator("_" + prop.Identifier.ValueText));
newMembers = newMembers.Add(Syntax.FieldDeclaration(Syntax.VariableDeclaration(prop.Type, variables)));
}
newMembers = newMembers.Add(prop.WithAccessorList(prop.AccessorList.WithAccessors(newAccessors)));
}
else
{
newMembers = newMembers.Add(member);
}
}
return node.WithMembers(newMembers);
}
private ClassDeclarationSyntax GetParentClass(SyntaxTree tree, ClassDeclarationSyntax theclass)
{
if (theclass != null && theclass.BaseListOpt!=null)
{
var parent = theclass.BaseListOpt.GetLastToken();
if (parent != null)
{
var node = tree.Root.DescendentNodes().OfType<ClassDeclarationSyntax>().Where(p => p.Identifier.GetText() == parent.GetText()).First();
return node;
}
}
return null;
}
private BeginEndRegionTrivia GetRegion(ClassDeclarationSyntax classDeclaration, string name)
{
using (var triviaEnumerator = classDeclaration.DescendantTrivia().GetEnumerator())
while (triviaEnumerator.MoveNext())
{
var beginRegionTrivia = triviaEnumerator.Current;
if (SyntaxKind.RegionDirective == beginRegionTrivia.Kind)
{
var text = beginRegionTrivia.GetText().Trim();
if (text.Trim().EndsWith(name))
{
// The #region is found, now looking for the matching #endregion
var prev = beginRegionTrivia;
var depth = 0;
while (triviaEnumerator.MoveNext())
{
var endRegionTrivia = triviaEnumerator.Current;
// Handle nested #regions...
if (SyntaxKind.RegionDirective == endRegionTrivia.Kind)
{
depth++;
}
else if (SyntaxKind.EndRegionDirective == endRegionTrivia.Kind)
{
if (0 == depth)
return new BeginEndRegionTrivia()
{
beginRegionTrivia = beginRegionTrivia,
endRegionTrivia = prev, // this places the text within the whitespace
whiteSpace = prev.GetText()
};
else
depth--;
}
prev = endRegionTrivia;
}
}
}
}
// No matching #region and #endregion found
return null;
}
public override void VisitClassDeclaration(ClassDeclarationSyntax node)
{
LS2IL.TypeExtraInfo.ClassMetadataGenerator wasClass = CurrentClass;
NamedTypeSymbol s = Model.GetDeclaredSymbol(node);
TypeExtraInfo tei = Chunk.AddTypeExtraInfo(s, Model);
CurrentClass = tei.MetadataGenerator;
foreach (MemberDeclarationSyntax mds in node.Members)
{
CurrentClass.AddMember(mds);
}
base.VisitClassDeclaration(node);
CurrentClass = wasClass;
}
protected override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
var callsTruthiness =
node.DescendentNodes().OfType<InvocationExpressionSyntax>()
.Select(i => i.Expression).OfType<IdentifierNameSyntax>()
.Any(a => a.PlainName == "__Truthy");
var allMethods = node.DescendentNodes().OfType<MethodDeclarationSyntax>().ToList();
if (callsTruthiness)
{
SyntaxList<MemberDeclarationSyntax> newMembers = Syntax.List(node.Members.Union(new[] { TruthyMethod }));
return node.Update(node.Attributes, node.Modifiers, node.Keyword, node.Identifier, node.TypeParameterListOpt, node.BaseListOpt, node.ConstraintClauses, node.OpenBraceToken, newMembers, node.CloseBraceToken, node.SemicolonTokenOpt);
}
return base.VisitClassDeclaration(node);
}
public static ClassDeclarationSyntax ClassDeclaration(IEnumerable<AttributeListSyntax> attributeLists = null, Modifiers modifiers = default(Modifiers), string identifier = null, TypeParameterListSyntax typeParameterList = null, BaseListSyntax baseList = null, IEnumerable<TypeParameterConstraintClauseSyntax> constraintClauses = null, IEnumerable<MemberDeclarationSyntax> members = null)
{
var result = new ClassDeclarationSyntax();
if (attributeLists != null)
result.AttributeLists.AddRange(attributeLists);
result.Modifiers = modifiers;
result.Identifier = identifier;
result.TypeParameterList = typeParameterList;
result.BaseList = baseList;
if (constraintClauses != null)
result.ConstraintClauses.AddRange(constraintClauses);
if (members != null)
result.Members.AddRange(members);
return result;
}
public InClassExtractMethodDetector(ClassDeclarationSyntax classBefore,
ClassDeclarationSyntax classAfter)
{
this.classBefore = classBefore;
this.classAfter = classAfter;
logger = NLoggerUtil.GetNLogger(typeof(InClassExtractMethodDetector));
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
return(VisitTypeDeclaration(node));
}
public static bool IsSealed(this ClassDeclarationSyntax classDeclaration)
{
return(classDeclaration.Modifiers
.Any(x => x.IsKind(SyntaxKind.SealedKeyword)));
}
private void Test(string expected, params AttributeListSyntax[] attributes)
{
var node = new ClassDeclarationSyntax
{
Identifier = "Class"
};
node.AttributeLists.AddRange(attributes);
Test(
expected +
@"class Class
{
}
",
node
);
}
public override void VisitClassDeclaration(ClassDeclarationSyntax node)
{
sb.AppendLine(node.Keyword.ValueText + " " + node.Identifier.ValueText);
base.VisitClassDeclaration(node);
}
/// <summary>
/// Checks for special properties.
/// </summary>
/// <param name="state">State</param>
/// <param name="compilation">Compilation</param>
protected override void CheckForSpecialProperties(ClassDeclarationSyntax state,
CodeAnalysis.Compilation compilation)
{
this.CheckForLivenessAttribute(state, compilation);
}
/// <summary>
/// Returns true if the given class declaration is a state.
/// </summary>
/// <param name="compilation">Compilation</param>
/// <param name="classDecl">Class declaration</param>
/// <returns>Boolean value</returns>
protected override bool IsState(CodeAnalysis.Compilation compilation, ClassDeclarationSyntax classDecl)
{
return(Querying.IsMachineState(compilation, classDecl));
}
// // Summary: // Called when the visitor visits a ClassDeclarationSyntax node. public virtual void VisitClassDeclaration(ClassDeclarationSyntax node);
public override void VisitClassDeclaration(ClassDeclarationSyntax node)
{
VisitTypeDeclarationImpl(node, _model.GetDeclaredSymbol(node));
base.VisitClassDeclaration(node);
}
public IEnumerable <MethodDeclarationSyntax> GetMethodsFromClass(
ClassDeclarationSyntax @class,
params Modifier[] modifiers) => GetMembersFromClass <MethodDeclarationSyntax>(@class, modifiers);
public static async Task <Solution> CreateMatchMethods(
Document document, ClassDeclarationSyntax classSyntax, SyntaxNode root, CancellationToken cancellationToken)
{
AttributeSyntax CreateMatchMethodAttribute(SyntaxAnnotation syntaxAnnotation)
{
return(SyntaxFactory.Attribute(
SyntaxFactory.IdentifierName("CreateMatchMethods"),
SyntaxFactory.AttributeArgumentList(
SyntaxFactory.SeparatedList(new[]
{
SyntaxFactory.AttributeArgument(
SyntaxFactory.TypeOfExpression(
SyntaxFactory.IdentifierName(classSyntax.Identifier.Text))),
}))).WithAdditionalAnnotations(syntaxAnnotation));
}
var originalSolution = document.Project.Solution;
var staticExtensionsClassName = classSyntax.Identifier.Text + "ExtensionMethods";
var annotationForAttributeSyntax = new SyntaxAnnotation();
var hostClass =
classSyntax.Parent.ChildNodes().OfType <ClassDeclarationSyntax>()
.Where(x => x.IsStatic() && x.Identifier.Text == staticExtensionsClassName)
.FirstOrNoValue();
if (hostClass.HasNoValue)
{
var newHostClass =
Utilities
.CreateEmptyPublicStaticClass(staticExtensionsClassName)
.WithAttributeLists(SyntaxFactory.List(new[]
{
SyntaxFactory.AttributeList(SyntaxFactory.SeparatedList(new[]
{
CreateMatchMethodAttribute(annotationForAttributeSyntax),
}))
}));
var newSolutionWithHostClassAdded = originalSolution.WithDocumentSyntaxRoot(document.Id,
root.InsertNodesAfter(classSyntax, new[] { newHostClass }));
var newDocument = newSolutionWithHostClassAdded.GetDocument(document.Id);
var newDocumentRoot = await newDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
return(await CreateMatchMethods(
newDocument,
(AttributeSyntax)newDocumentRoot.GetAnnotatedNodes(annotationForAttributeSyntax).Single(),
newDocumentRoot,
cancellationToken).ConfigureAwait(false));
}
else
{
var hostClassValue = hostClass.GetValue();
var existingAttribute = hostClassValue.AttributeLists.SelectMany(x => x.Attributes)
.FirstOrNoValue(Utilities.IsCreateMatchMethodsAttribute);
if (existingAttribute.HasNoValue)
{
var updatedHostClass = hostClassValue.AddAttributeLists(SyntaxFactory.AttributeList(
SyntaxFactory.SeparatedList(new[]
{
CreateMatchMethodAttribute(annotationForAttributeSyntax),
})));
var newSolutionWithHostClassAdded = originalSolution.WithDocumentSyntaxRoot(document.Id,
root.ReplaceNode(hostClassValue, updatedHostClass));
var newDocument = newSolutionWithHostClassAdded.GetDocument(document.Id);
var newDocumentRoot = await newDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
return(await CreateMatchMethods(
newDocument,
(AttributeSyntax)newDocumentRoot.GetAnnotatedNodes(annotationForAttributeSyntax).Single(),
newDocumentRoot,
cancellationToken).ConfigureAwait(false));
}
else
{
return(await CreateMatchMethods(
document,
existingAttribute.GetValue(),
root,
cancellationToken).ConfigureAwait(false));
}
}
}
private async Task <Document> AddMixinAttribute(CodeRefactoringContext context, ClassDeclarationSyntax @class, TypeSyntax baseType, CancellationToken ct)
{
var root = await context.Document.GetSyntaxRootAsync(ct).ConfigureAwait(false);
var newClass = @class.WithAttributeLists(@class.AttributeLists.Add(
AttributeList(
SeparatedList(new[] {
Attribute(IdentifierName(nameof(Mixin)),
AttributeArgumentList(SeparatedList(new[] { AttributeArgument(TypeOfExpression(baseType.WithoutTrivia())) }))
)
})
).WithAdditionalAnnotations(Formatter.Annotation)
));
root = root.ReplaceNode(@class, newClass);
return(context.Document.WithSyntaxRoot(root));
}
public static GenericInfo GenericInfo(ClassDeclarationSyntax classDeclaration)
{
return(Syntax.GenericInfo.Create(classDeclaration));
}
public override void VisitClassDeclaration(ClassDeclarationSyntax node)
{
var model = CreateModel(node);
Models.Add(model);
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, ClassDeclarationSyntax classDeclaration)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddTypeParameter))
{
AddTypeParameterRefactoring.ComputeRefactoring(context, classDeclaration);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ExtractTypeDeclarationToNewFile))
{
ExtractTypeDeclarationToNewFileRefactoring.ComputeRefactorings(context, classDeclaration);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.GenerateBaseConstructors) &&
classDeclaration.Identifier.Span.Contains(context.Span))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
List <IMethodSymbol> constructors = GenerateBaseConstructorsRefactoring.GetMissingBaseConstructors(classDeclaration, semanticModel, context.CancellationToken);
if (constructors?.Count > 0)
{
context.RegisterRefactoring(
(constructors.Count == 1) ? "Generate base constructor" : "Generate base constructors",
cancellationToken => GenerateBaseConstructorsRefactoring.RefactorAsync(context.Document, classDeclaration, constructors.ToArray(), semanticModel, cancellationToken));
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ImplementIEquatableOfT))
{
await ImplementIEquatableOfTRefactoring.ComputeRefactoringAsync(context, classDeclaration).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.SortMemberDeclarations) &&
classDeclaration.BracesSpan().Contains(context.Span))
{
SortMemberDeclarationsRefactoring.ComputeRefactoring(context, classDeclaration);
}
}
static Controller AnalyzeApiControllerActions(
Compilation compilation,
ClassDeclarationSyntax classDeclaration,
SemanticModel semanticModel,
Dictionary <string, Compilation> referencedSymbols)
{
var routePrefixSymbol = compilation.GetTypeByMetadataName("System.Web.Http.RoutePrefixAttribute");
// Get the class and containing namespace symbols.
var classSymbol = semanticModel.GetDeclaredSymbol(classDeclaration);
var namespaceSymbol = classSymbol.ContainingNamespace;
var controller = new Controller
{
DocumentationCommentId = classSymbol.GetDocumentationCommentId(),
Namespace = classSymbol.ContainingNamespace?.ToFullName(),
Name = classSymbol.Name,
Actions = new List <Action>()
};
// Go through the class's XML comments, if any.
var classCommentXml = classSymbol.GetDocumentationCommentXml();
if (!string.IsNullOrWhiteSpace(classCommentXml))
{
var classCommentRoot = XElement.Parse(classCommentXml);
var summary = classCommentRoot.Element("summary");
if (summary != null)
{
foreach (var cref in summary.GetCrefs())
{
if (!referencedSymbols.ContainsKey(cref))
{
referencedSymbols.Add(cref, compilation);
}
}
controller.Summary = summary.ToMarkup();
}
var remarks = classCommentRoot.Element("remarks");
if (remarks != null)
{
foreach (var cref in remarks.GetCrefs())
{
if (!referencedSymbols.ContainsKey(cref))
{
referencedSymbols.Add(cref, compilation);
}
}
controller.Remarks = remarks.ToMarkup();
}
}
// Go through the class's attributes, if any.
var routePrefix = string.Empty;
foreach (var attributeList in classDeclaration.AttributeLists)
{
foreach (var attribute in attributeList.Attributes)
{
// For each attribute, try to pull a recognized value.
var attributeTypeInfo = semanticModel.GetTypeInfo(attribute);
if (attributeTypeInfo.Type.MetadataName == routePrefixSymbol.MetadataName)
{
var routePrefixArgument = attribute
.ArgumentList
.Arguments
.Single()
.Expression as LiteralExpressionSyntax;
routePrefix = routePrefixArgument.Token.ValueText + "/";
}
}
}
// Get all public methods.
var actionMethodDeclarations = classDeclaration
.DescendantNodes()
.Where(n => n.IsKind(SyntaxKind.MethodDeclaration))
.Cast <MethodDeclarationSyntax>()
.Where(m => m.Modifiers.Any(mo => mo.ValueText == "public"))
.ToList();
foreach (var actionMethodDeclaration in actionMethodDeclarations)
{
var action = AnalyzeActionMethod(
compilation,
semanticModel,
actionMethodDeclaration,
referencedSymbols,
routePrefix);
if (!string.IsNullOrWhiteSpace(action.Method))
{
controller.Actions.Add(action);
}
}
return(controller);
}
private async Task <Document> HandleMacroInsideClass(Document document, Location diagnosticLocation, CancellationToken cancellationToken, ClassDeclarationSyntax block)
{
foreach (var statement in block.Members)
{
var triviaList = statement.GetLeadingTrivia();
if (Contains(statement.GetLocation(), diagnosticLocation) &&
TryGetMacroDescriptor(triviaList, out var macroDescriptor, out var leadingTrivia))
{
if (registeredMacros.TryGetValue(macroDescriptor.MacroName, out var macro))
{
var macroContext = await CreateMacroContext(document, diagnosticLocation, cancellationToken);
var newContent = TransformContent(macro, macroDescriptor, macroContext);
var syntaxTree = SyntaxFactory.ParseSyntaxTree(newContent);
var newBlock = block.ReplaceNode(statement, syntaxTree.GetRoot().ChildNodes().Concat(new SyntaxNode[]
{
statement.WithLeadingTrivia(triviaList.LastOrDefault())
}));
return(await ReplaceNodes(document, block, newBlock.WithAdditionalAnnotations(Formatter.Annotation),
cancellationToken));
}
return(document);
}
}
{
if (Contains(block.CloseBraceToken.GetLocation(), diagnosticLocation) &&
TryGetMacroDescriptor(block.CloseBraceToken.LeadingTrivia, out var macroDescriptor1, out var leadingTrivia))
{
if (registeredMacros.TryGetValue(macroDescriptor1.MacroName, out var macro))
{
var macroContext = await CreateMacroContext(document, diagnosticLocation, cancellationToken);
var newContent = TransformContent(macro, macroDescriptor1, macroContext);
var syntaxTree = SyntaxFactory.ParseSyntaxTree(newContent);
var newBlock =
block.AddMembers(syntaxTree.GetRoot().ChildNodes().OfType <MemberDeclarationSyntax>().ToArray());
newBlock = newBlock.WithCloseBraceToken(
block.CloseBraceToken.WithLeadingTrivia(block.CloseBraceToken.LeadingTrivia.LastOrDefault()));
return(await ReplaceNodes(document, block, newBlock.WithAdditionalAnnotations(Formatter.Annotation),
cancellationToken));
}
}
}
return(document);
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out BaseListSyntax baseList))
{
return;
}
if (baseList.ContainsDiagnostics)
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.BaseClassMustComeBeforeAnyInterface:
{
if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.MoveBaseClassBeforeAnyInterface))
{
return;
}
SeparatedSyntaxList <BaseTypeSyntax> types = baseList.Types;
if (types.Count > 1)
{
BaseTypeSyntax baseType = types.First(f => context.Span.Contains(f.Span));
CodeAction codeAction = CodeAction.Create(
$"Move '{baseType.Type}' before any interface",
cancellationToken =>
{
BaseTypeSyntax firstType = types[0];
SeparatedSyntaxList <BaseTypeSyntax> newTypes = types
.Replace(baseType, firstType.WithTriviaFrom(baseType))
.ReplaceAt(0, baseType.WithTriviaFrom(firstType));
BaseListSyntax newBaseList = baseList.WithTypes(newTypes);
return(context.Document.ReplaceNodeAsync(baseList, newBaseList, cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
case CompilerDiagnosticIdentifiers.StaticClassCannotDeriveFromType:
case CompilerDiagnosticIdentifiers.StaticClassCannotImplementInterfaces:
{
if (!(baseList.Parent is ClassDeclarationSyntax classDeclaration))
{
break;
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.MakeClassNonStatic))
{
ModifiersCodeFixRegistrator.RemoveModifier(
context,
diagnostic,
classDeclaration,
SyntaxKind.StaticKeyword,
title: "Make class non-static",
additionalKey: CodeFixIdentifiers.MakeClassNonStatic);
}
if (Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.RemoveBaseList))
{
CodeAction codeAction = CodeAction.Create(
"Remove base list",
cancellationToken =>
{
SyntaxToken token = baseList.GetFirstToken().GetPreviousToken();
SyntaxTriviaList trivia = token.TrailingTrivia.EmptyIfWhitespace()
.AddRange(baseList.GetLeadingTrivia().EmptyIfWhitespace())
.AddRange(baseList.GetTrailingTrivia());
ClassDeclarationSyntax newNode = classDeclaration
.ReplaceToken(token, token.WithTrailingTrivia(trivia))
.WithBaseList(null);
return(context.Document.ReplaceNodeAsync(classDeclaration, newNode, cancellationToken));
},
base.GetEquivalenceKey(diagnostic, CodeFixIdentifiers.RemoveBaseList));
context.RegisterCodeFix(codeAction, diagnostic);
}
break;
}
}
}
}
public override void VisitClassDeclaration(ClassDeclarationSyntax node)
{
ClassDeclaration = node;
base.VisitClassDeclaration(node);
}
public override void VisitClassDeclaration(ClassDeclarationSyntax node)
{
VisitBody(node);
}
private ClassDeclarationSyntax AddSubscriptions(ClassDeclarationSyntax classSyntax, SemanticModel model, ClassDeclarationSyntax classDeclaration)
{
var commands = GetMethodList(classSyntax, model, "Command", "Subscribe");
var events = GetMethodList(classSyntax, model, "Event", "Subscribe");
var queries = GetMethodList(classSyntax, model, "Query", "Subscribe");
if (commands.Count + queries.Count + events.Count > 0)
{
var baseClassInvoke = ExpressionStatement(AwaitExpression(InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, BaseExpression(), IdentifierName("OnStarted"))).WithArgumentList(ArgumentList(SingletonSeparatedList <ArgumentSyntax>(Argument(IdentifierName("context"))))), IdentifierName("ConfigureAwait"))).WithArgumentList(ArgumentList(SingletonSeparatedList <ArgumentSyntax>(Argument(LiteralExpression(SyntaxKind.FalseLiteralExpression)))))));
List <StatementSyntax> statementSyntaxes = new List <StatementSyntax>
{
baseClassInvoke
};
foreach (var method in commands)
{
var parentSubscription = IsSubscribeToParent(method);
var invocation = InvocationExpression(GenericName(Identifier("Subscribe")).WithTypeArgumentList(TypeArgumentList(SingletonSeparatedList <TypeSyntax>(IdentifierName(method.Parameter.Type.Name)))));
if (parentSubscription)
{
invocation = invocation.WithArgumentList(ArgumentList(SingletonSeparatedList(Argument(LiteralExpression(SyntaxKind.TrueLiteralExpression)))));
}
statementSyntaxes.Add(ExpressionStatement(invocation));
}
foreach (var method in events)
{
var parentSubscription = IsSubscribeToParent(method);
var invocation = InvocationExpression(GenericName(Identifier("Subscribe")).WithTypeArgumentList(TypeArgumentList(SingletonSeparatedList <TypeSyntax>(IdentifierName(method.Parameter.Type.Name)))));
if (parentSubscription)
{
invocation = invocation.WithArgumentList(ArgumentList(SingletonSeparatedList(Argument(LiteralExpression(SyntaxKind.TrueLiteralExpression)))));
}
statementSyntaxes.Add(ExpressionStatement(invocation));
}
foreach (var method in queries)
{
var parentSubscription = IsSubscribeToParent(method);
InvocationExpressionSyntax invocation;
if (method.ReturnType is INamedTypeSymbol namedSymbol && namedSymbol.TypeArguments.Length > 0)
{
var arg = namedSymbol.TypeArguments[0];
invocation = InvocationExpression(GenericName(Identifier("Subscribe")).WithTypeArgumentList(TypeArgumentList(SeparatedList <TypeSyntax>(new SyntaxNodeOrToken[] { IdentifierName(method.Parameter.Type.Name), Token(SyntaxKind.CommaToken), IdentifierName(arg.Name) }))));
}
else if (!string.IsNullOrWhiteSpace(method.ReturnType.Name))
{
invocation = InvocationExpression(GenericName(Identifier("Subscribe")).WithTypeArgumentList(TypeArgumentList(SeparatedList <TypeSyntax>(new SyntaxNodeOrToken[] { IdentifierName(method.Parameter.Type.Name), Token(SyntaxKind.CommaToken), IdentifierName(method.ReturnType.Name) }))));
}
else
{
invocation = InvocationExpression(GenericName(Identifier("Subscribe")).WithTypeArgumentList(TypeArgumentList(SeparatedList <TypeSyntax>(new SyntaxNodeOrToken[] { IdentifierName(method.Parameter.Type.Name), Token(SyntaxKind.CommaToken), IdentifierName(method.ReturnType.ToString()) }))));
}
if (parentSubscription)
{
invocation = invocation.WithArgumentList(ArgumentList(SingletonSeparatedList(Argument(LiteralExpression(SyntaxKind.TrueLiteralExpression)))));
}
statementSyntaxes.Add(ExpressionStatement(invocation));
}
protected override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
AttributeSyntax attribute = node.Attributes
.SelectMany(a => a.ChildNodes().OfType<AttributeSyntax>())
.FirstOrDefault(a => a.Name.PlainName == "EnableSingleton");
if (attribute == null)
return base.VisitClassDeclaration(node);
LiteralExpressionSyntax argument = (LiteralExpressionSyntax) attribute
.ArgumentListOpt
.Arguments
.First()
.Expression;
VariableDeclaratorSyntax syncVariable = Syntax.VariableDeclarator(identifier: Syntax.Identifier("_sync"));
FieldDeclarationSyntax syncField = Syntax.FieldDeclaration(
modifiers: Syntax.TokenList(Syntax.Token(SyntaxKind.PrivateKeyword), Syntax.Token(SyntaxKind.StaticKeyword)),
declaration: Syntax.VariableDeclaration(
type: Syntax.ParseTypeName("System.Object"),
variables: Syntax.SeparatedList(syncVariable)));
VariableDeclaratorSyntax instanceVariable = Syntax.VariableDeclarator(identifier: Syntax.Identifier("_instance"));
FieldDeclarationSyntax instanceField = Syntax.FieldDeclaration(
modifiers: Syntax.TokenList(Syntax.Token(SyntaxKind.PrivateKeyword), Syntax.Token(SyntaxKind.StaticKeyword)),
declaration: Syntax.VariableDeclaration(
type: Syntax.ParseTypeName(node.Identifier.ValueText),
variables: Syntax.SeparatedList(instanceVariable)));
ConstructorDeclarationSyntax constructor = Syntax.ConstructorDeclaration(
modifiers: Syntax.TokenList(Syntax.Token(SyntaxKind.StaticKeyword)),
identifier: Syntax.Identifier(node.Identifier.ValueText),
parameterList: Syntax.ParameterList(parameters: Syntax.SeparatedList<ParameterSyntax>()),
bodyOpt: Syntax.Block(
statements: Syntax.List<StatementSyntax>(Syntax.ExpressionStatement(Syntax.ParseExpression("_sync = new Object()")))));
IfStatementSyntax ifStatement = Syntax.IfStatement(
ifKeyword: Syntax.Token(SyntaxKind.IfKeyword),
condition: Syntax.BinaryExpression(SyntaxKind.EqualsExpression, Syntax.IdentifierName("_instance"),
right: Syntax.LiteralExpression(SyntaxKind.NullLiteralExpression)),
statement: Syntax.ExpressionStatement(Syntax.BinaryExpression(SyntaxKind.AssignExpression, Syntax.IdentifierName("_instance"),
right: Syntax.ObjectCreationExpression(
newKeyword: Syntax.Token(SyntaxKind.NewKeyword),
type: Syntax.ParseTypeName(node.Identifier.ValueText),
argumentListOpt: Syntax.ArgumentList(arguments: Syntax.SeparatedList<ArgumentSyntax>())))));
LockStatementSyntax lockStatement = Syntax.LockStatement(
lockKeyword: Syntax.Token(SyntaxKind.LockKeyword),
expression: Syntax.IdentifierName("_sync"),
statement: Syntax.Block(
statements: Syntax.List<StatementSyntax>(ifStatement, Syntax.ParseStatement("return _instance"))));
//Syntax.BinaryExpression(SyntaxKind.EqualsEqualsExpression, Syntax.IdentifierName("_instance"));
//Syntax.LiteralExpression(SyntaxKind.NullKeyword);
//Syntax.ExpressionStatement(Syntax.BinaryExpression(SyntaxKind.AssignExpression, Syntax.IdentifierName("_instance")));
//Syntax.ObjectCreationExpression(
// type: Syntax.ParseTypeName(node.Identifier.ValueText),
// argumentListOpt: Syntax.ArgumentList(arguments: Syntax.SeparatedList<ArgumentSyntax>()),
// initializerOpt: Syntax.InitializerExpression(expressions: Syntax.SeparatedList<ExpressionSyntax>(Syntax.Identifier(node.Identifier.ValueText))));
//StatementSyntax getter = Syntax.ReturnStatement(expressionOpt: cast);
PropertyDeclarationSyntax instance = Syntax.PropertyDeclaration(
modifiers: Syntax.TokenList(Syntax.Token(SyntaxKind.PublicKeyword), Syntax.Token(SyntaxKind.StaticKeyword)),
type: Syntax.ParseTypeName(node.Identifier.ValueText),
identifier: Syntax.Identifier(argument.Token.ValueText),
accessorList: Syntax.AccessorList(
accessors: Syntax.List(
Syntax.AccessorDeclaration(
kind: SyntaxKind.GetAccessorDeclaration,
bodyOpt: Syntax.Block(
statements: Syntax.List<StatementSyntax>(lockStatement)
)
)
)
)
);
var newTypeDeclaration = (TypeDeclarationSyntax)base.VisitClassDeclaration(node);
var members = new List<MemberDeclarationSyntax>(newTypeDeclaration.Members);
members.Add(syncField);
members.Add(instanceField);
members.Add(constructor);
members.Add(instance);
return ((ClassDeclarationSyntax)newTypeDeclaration).Update(
newTypeDeclaration.Attributes,
newTypeDeclaration.Modifiers,
newTypeDeclaration.Keyword,
newTypeDeclaration.Identifier,
newTypeDeclaration.TypeParameterListOpt,
newTypeDeclaration.BaseListOpt,
newTypeDeclaration.ConstraintClauses,
newTypeDeclaration.OpenBraceToken,
Syntax.List(members.AsEnumerable()),
newTypeDeclaration.CloseBraceToken,
newTypeDeclaration.SemicolonTokenOpt);
}
private static NamespaceDeclarationSyntax AddNamespace(ClassDeclarationSyntax classSyntax, ClassDeclarationSyntax classDeclaration)
{
return(NamespaceDeclaration((classSyntax.Parent as NamespaceDeclarationSyntax)?.Name).AddMembers(classDeclaration));
}
private ClassDeclarationSyntax AddIActionResultProperties(ClassDeclarationSyntax node)
=> node
.WithAutoStringProperty("Controller", SyntaxKind.PublicKeyword)
.WithAutoStringProperty("Action", SyntaxKind.PublicKeyword)
.WithAutoStringProperty("Protocol", SyntaxKind.PublicKeyword)
.WithAutoProperty("RouteValueDictionary", IdentifierName("RouteValueDictionary"), SyntaxKind.PublicKeyword);
private static Dictionary <string, string> CreateConstants(
IReadOnlyCollection <string> constantsToCreate,
ClassDeclarationSyntax classNode,
DocumentEditor editor)
{
var result = new Dictionary <string, string>();
if (!constantsToCreate.Any())
{
return(result);
}
var trivia = classNode.GetLeadingTrivia().ToString();
trivia = trivia.Substring(trivia.LastIndexOf('\n') + 1);
string indent;
if (string.IsNullOrEmpty(trivia))
{
indent = " ";
}
else
{
indent = trivia + trivia;
}
var counter = 0;
var newConstants = new List <MemberDeclarationSyntax>();
foreach (var constant in constantsToCreate)
{
counter++;
var constantSubstring = SyntaxFactory.ParseToken(constant);
var constName = GetConstantName(constantSubstring.ValueText, result, classNode, counter);
var constSyntax = SyntaxFactory.FieldDeclaration(
SyntaxFactory
.VariableDeclaration(
SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)))
.WithVariables(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(constName))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
constantSubstring))))))
.WithModifiers(
SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.PrivateKeyword),
SyntaxFactory.Token(SyntaxKind.ConstKeyword)))
.NormalizeWhitespace()
.WithLeadingTrivia(SyntaxFactory.Whitespace(indent))
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
newConstants.Add(constSyntax);
result.Add(constant, constName);
}
editor.InsertMembers(classNode, 0, newConstants);
return(result);
}
// ******************************************************************************
// **************** Skip any nodes that change scope without a block node *******
// ******************************************************************************
// **
// **
protected override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
return node;
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, ClassDeclarationSyntax classDeclaration)
{
SyntaxToken identifier = classDeclaration.Identifier;
if (identifier.IsMissing)
{
return;
}
TextSpan span = identifier.Span;
BaseListSyntax baseList = classDeclaration.BaseList;
if (baseList != null)
{
span = TextSpan.FromBounds(span.Start, baseList.Span.End);
}
TypeParameterListSyntax typeParameterList = classDeclaration.TypeParameterList;
if (typeParameterList != null)
{
span = TextSpan.FromBounds(span.Start, typeParameterList.Span.End);
}
if (!span.Contains(context.Span))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
INamedTypeSymbol classSymbol = semanticModel.GetDeclaredSymbol(classDeclaration, context.CancellationToken);
if (classSymbol?.IsErrorType() != false)
{
return;
}
if (classSymbol.IsStatic)
{
return;
}
foreach (INamedTypeSymbol interfaceSymbol in classSymbol.AllInterfaces)
{
if (interfaceSymbol.HasMetadataName(MetadataNames.System_IEquatable_T) &&
SymbolEqualityComparer.Default.Equals(interfaceSymbol.TypeArguments.Single(), classSymbol))
{
return;
}
}
INamedTypeSymbol equatableSymbol = semanticModel.GetTypeByMetadataName("System.IEquatable`1");
if (equatableSymbol == null)
{
return;
}
equatableSymbol = equatableSymbol.Construct(classSymbol);
context.RegisterRefactoring(
GetTitle(equatableSymbol, semanticModel, classDeclaration.SpanStart),
ct => RefactorAsync(context.Document, classDeclaration, classSymbol, equatableSymbol, semanticModel, ct),
RefactoringIdentifiers.ImplementIEquatableOfT);
}
public static ClassDeclarationSyntax ClassDeclaration(string identifier = null)
{
var result = new ClassDeclarationSyntax();
result.Identifier = identifier;
return result;
}
private static IEnumerable <ObjectCreationExpressionSyntax> GetObjectCreations(SyntaxNodeAnalysisContext context, ClassDeclarationSyntax classDeclaration, PropertyDeclarationSyntax propertyDeclarationSyntax, IPropertySymbol propertySymbol)
{
var objectCreations = classDeclaration.DescendantNodes()
.OfType <AssignmentExpressionSyntax>()
.Where(a => context.SemanticModel.GetSymbolInfo(a.Left).Symbol.Equals(propertySymbol) && a.Right is ObjectCreationExpressionSyntax)
.Select(a => a.Right as ObjectCreationExpressionSyntax).ToList();
var arrowExpressionClause = propertyDeclarationSyntax.DescendantNodes()
.OfType <ArrowExpressionClauseSyntax>()
.SingleOrDefault(a => a.Expression is ObjectCreationExpressionSyntax)
?.Expression as ObjectCreationExpressionSyntax;
if (arrowExpressionClause != null)
{
objectCreations.Add(arrowExpressionClause);
}
var getAcessorDeclararion = propertyDeclarationSyntax.DescendantNodes()
.OfType <AccessorDeclarationSyntax>()
.SingleOrDefault(a => a.IsKind(SyntaxKind.GetAccessorDeclaration));
if (getAcessorDeclararion != null)
{
objectCreations.AddRange(getAcessorDeclararion.DescendantNodes()
.OfType <ObjectCreationExpressionSyntax>());
}
return(objectCreations);
}
public static IEnumerable <EventFieldDeclarationSyntax> GetEventFiels(this ClassDeclarationSyntax classDeclaration)
{
return(classDeclaration.Members
.Where(x => x.IsKind(SyntaxKind.EventFieldDeclaration))
.OfType <EventFieldDeclarationSyntax>());
}
public static ITypeSymbol AddType(DotNetProject project, string folder, string namspace, ClassDeclarationSyntax type)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (folder == null)
{
throw new ArgumentNullException(nameof(folder));
}
if (namspace == null)
{
throw new ArgumentNullException(nameof(namspace));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var ns = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(namspace)).WithMembers(new SyntaxList <MemberDeclarationSyntax> ()
{
type
});
string fileName = project.LanguageBinding.GetFileName(Path.Combine(folder, type.Identifier.ToString()));
using (var sw = new StreamWriter(fileName)) {
sw.WriteLine(ns.ToString());
}
FileService.NotifyFileChanged(fileName);
var roslynProject = MonoDevelop.Ide.TypeSystem.TypeSystemService.GetCodeAnalysisProject(project);
var id = MonoDevelop.Ide.TypeSystem.TypeSystemService.GetDocumentId(roslynProject.Id, fileName);
if (id == null)
{
return(null);
}
var model = roslynProject.GetDocument(id).GetSemanticModelAsync().Result;
var typeSyntax = model.SyntaxTree.GetCompilationUnitRoot().ChildNodes().First().ChildNodes().First() as ClassDeclarationSyntax;
return(model.GetDeclaredSymbol(typeSyntax));
}
public DisposableChecker(ClassDeclarationSyntax classDeclaration, SemanticModel semanticModel)
{
this.classDeclaration = classDeclaration;
this.semanticModel = semanticModel;
this.classSymbol = semanticModel.GetDeclaredSymbol(classDeclaration);
}
public AdaptInterfaceCodeAction(IDocument document, ClassDeclarationSyntax classDeclaration, ParameterSyntax parameterSyntax)
{
this._document = document;
_classDeclaration = classDeclaration;
Description = "Adapt "+parameterSyntax.Type;
}
public virtual void VisitClassDeclaration(ClassDeclarationSyntax node)
{
DefaultVisit(node);
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
var symbol = semanticModel.GetDeclaredSymbol(node);
var visitedNode = base.VisitClassDeclaration(node);
return VisitTypeDeclaration(visitedNode as TypeDeclarationSyntax, symbol);
}
// Replace old ClassDeclarationSyntax with new one.
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
var updatedClassDeclaration = (ClassDeclarationSyntax)base.VisitClassDeclaration(node);
// Get TypeSymbol corresponding to the ClassDeclarationSyntax and check whether
// it is the same as the TypeSymbol we are searching for.
TypeSymbol classSymbol = SemanticModel.GetDeclaredSymbol(node);
if (classSymbol.Equals(SearchSymbol))
{
// Replace the identifier token containing the name of the class.
SyntaxToken updatedIdentifierToken =
Syntax.Identifier(
updatedClassDeclaration.Identifier.LeadingTrivia,
NewName,
updatedClassDeclaration.Identifier.TrailingTrivia);
updatedClassDeclaration = updatedClassDeclaration.WithIdentifier(updatedIdentifierToken);
}
return updatedClassDeclaration;
}
public static IEnumerable <PropertyDeclarationSyntax> GetProperties(this ClassDeclarationSyntax classDeclaration)
{
return(classDeclaration.Members
.Where(x => x.IsKind(SyntaxKind.PropertyDeclaration))
.OfType <PropertyDeclarationSyntax>());
}
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node)
{
return base.VisitClassDeclaration(node);
}
public void VisitClassDeclaration(ClassDeclarationSyntax node)
{
VisitTypeDeclaration(node);
}
private ClassDeclarationSyntax AddReciveMapMethod(ClassDeclarationSyntax classSyntax, SemanticModel model, ClassDeclarationSyntax classDeclaration)
{
var methodDeclaration = MethodDeclaration(ParseTypeName("Task"), "ReceiveAsyncInternal")
.WithModifiers(TokenList(new[] { Token(SyntaxKind.ProtectedKeyword), Token(SyntaxKind.AsyncKeyword), Token(SyntaxKind.OverrideKeyword) }))
.WithParameterList(ParameterList(SingletonSeparatedList(Parameter(Identifier("context")).WithType(QualifiedName(IdentifierName("Proto"), IdentifierName("IContext"))))))
.WithBody(Block(
GenerateSystemMessagesHandler(),
FormatMessage(),
FillContextData(),
GenerateCommandHandlers(classSyntax, model),
GenerateQueryHandlers(classSyntax, model),
GenerateEventdHandlers(classSyntax, model),
GetUnsupportedMessage())
);
classDeclaration = classDeclaration.AddMembers(methodDeclaration);
return(classDeclaration);
}
public static IEnumerable <IndexerDeclarationSyntax> GetIndexers(this ClassDeclarationSyntax classDeclaration)
{
return(classDeclaration.Members
.Where(x => x.IsKind(SyntaxKind.IndexerDeclaration))
.OfType <IndexerDeclarationSyntax>());
}
public override void VisitClassDeclaration(ClassDeclarationSyntax node)
{
string className = node.Identifier.GetText();
_writer.WriteLine("var {0} = function() {{", className);
_writer.WriteLine(" var self = this;");
base.VisitClassDeclaration(node);
_writer.WriteLine(" return {");
_writer.Write(_publicCode.ToString());
_writer.WriteLine(" };");
_writer.WriteLine("}};");
}
