private TypeDeclarationSyntax TransformField(FieldTransformationResult fieldTransform, TypeDeclarationSyntax newTypeNode, TypeTransformationResult transformResult, INamespaceTransformationMetadata namespaceMetadata, SyntaxTrivia memberWhitespace, bool onlyMissingMembers) { var fieldNode = newTypeNode.GetAnnotatedNodes(fieldTransform.Annotation) .OfType <BaseFieldDeclarationSyntax>() .First(); var transformedNode = TransformField(fieldNode, !onlyMissingMembers, fieldTransform, transformResult, namespaceMetadata); newTypeNode = transformedNode.Transformed != null ? newTypeNode.ReplaceNode(fieldNode, transformedNode.Transformed) : newTypeNode.RemoveNodeKeepDirectives(transformedNode.Annotation, memberWhitespace, transformResult.EndOfLineTrivia); return(newTypeNode); }
private RootTypeTransformationResult TransformType(ITypeAnalyzationResult rootTypeResult, INamespaceTransformationMetadata namespaceMetadata, bool onlyMissingMembers) { var rootTypeNode = rootTypeResult.Node; var startRootTypeSpan = rootTypeNode.SpanStart; var rootTransformResult = new RootTypeTransformationResult(rootTypeResult) { MemberNames = rootTypeResult.Symbol.MemberNames.ToImmutableHashSet() }; // We do this here because we want that the root node has span start equal to 0 rootTypeNode = rootTypeNode.WithAdditionalAnnotations(new SyntaxAnnotation(rootTransformResult.Annotation)); startRootTypeSpan -= rootTypeNode.SpanStart; // Before any modification we need to annotate nodes that will be transformed in order to find them later on. // We cannot rely on spans as they changes each time the node is modified. // We need to annotate also the ignored types to be later removed foreach (var typeResult in rootTypeResult.GetSelfAndDescendantsTypes()) { var typeSpanStart = typeResult.Node.SpanStart - startRootTypeSpan; var typeSpanLength = typeResult.Node.Span.Length; var typeNode = rootTypeNode.DescendantNodesAndSelf().OfType <TypeDeclarationSyntax>() .First(o => o.SpanStart == typeSpanStart && o.Span.Length == typeSpanLength); var leadingWhitespace = typeNode.GetLeadingWhitespace(); TypeTransformationResult transformResult; if (typeNode == rootTypeNode) { transformResult = rootTransformResult; transformResult.IndentTrivia = typeNode.GetIndent(leadingWhitespace, namespaceMetadata.LeadingWhitespaceTrivia); } else { transformResult = new TypeTransformationResult(typeResult) { MemberNames = typeResult.Symbol.MemberNames.ToImmutableHashSet(), IndentTrivia = typeNode.GetIndent(leadingWhitespace) }; rootTypeNode = rootTypeNode.ReplaceNode(typeNode, typeNode.WithAdditionalAnnotations(new SyntaxAnnotation(transformResult.Annotation))); rootTransformResult.DescendantTransformedTypes.Add(transformResult); } transformResult.LeadingWhitespaceTrivia = leadingWhitespace; transformResult.EndOfLineTrivia = typeNode.GetEndOfLine(); if (typeResult.Conversion == TypeConversion.Ignore) { continue; // The ignored type shall be only annotated } // TypeReferences can be changes only if we create a new type if (typeResult.Conversion == TypeConversion.NewType || typeResult.Conversion == TypeConversion.Copy) { foreach (var typeReference in typeResult.TypeReferences.Where(o => o.TypeAnalyzationResult.Conversion == TypeConversion.NewType)) { var reference = typeReference.ReferenceLocation; var refSpanStart = reference.Location.SourceSpan.Start - startRootTypeSpan; var refSpanLength = reference.Location.SourceSpan.Length; var nameNode = rootTypeNode.GetSimpleName(refSpanStart, refSpanLength, typeReference.IsCref); var transformedNode = new TransformationResult(nameNode) { Transformed = nameNode.WithIdentifier(Identifier(nameNode.Identifier.ValueText + "Async").WithTriviaFrom(nameNode.Identifier)) }; transformResult.TransformedNodes.Add(transformedNode); rootTypeNode = rootTypeNode.ReplaceNode(nameNode, nameNode.WithAdditionalAnnotations(new SyntaxAnnotation(transformedNode.Annotation))); } } foreach (var fieldResult in typeResult.Fields) { var fieldSpanStart = fieldResult.Node.SpanStart - startRootTypeSpan; var fieldSpanLength = fieldResult.Node.Span.Length; var fieldNode = rootTypeNode.DescendantNodes() .OfType <BaseFieldDeclarationSyntax>() .First(o => o.SpanStart == fieldSpanStart && o.Span.Length == fieldSpanLength); var transformedNode = new FieldTransformationResult(fieldResult); transformResult.TransformedFields.Add(transformedNode); rootTypeNode = rootTypeNode.ReplaceNode(fieldNode, fieldNode.WithAdditionalAnnotations(new SyntaxAnnotation(transformedNode.Annotation))); } // Annotate and save an empty method transformation result foreach (var methodResult in typeResult.Methods /*.Where(o => o.Conversion != MethodConversion.Ignore)*/) { var methodSpanStart = methodResult.Node.SpanStart - startRootTypeSpan; var methodSpanLength = methodResult.Node.Span.Length; var methodNode = rootTypeNode.DescendantNodes() .OfType <MethodDeclarationSyntax>() .First(o => o.SpanStart == methodSpanStart && o.Span.Length == methodSpanLength); // Only create the transformation result for the method and transform the method later as the method may change // (a directive may be added to the method when removing type members) var transformedNode = new MethodTransformationResult(methodResult); transformResult.TransformedMethods.Add(transformedNode); rootTypeNode = rootTypeNode.ReplaceNode(methodNode, methodNode.WithAdditionalAnnotations(new SyntaxAnnotation(transformedNode.Annotation))); // Annotate all locks inside the method before the transformations begins as will be easier to transform them if needed foreach (var lockData in methodResult.Locks) { var lockSpanStart = lockData.Node.SpanStart - startRootTypeSpan; var lockSpanLength = lockData.Node.Span.Length; var lockNode = rootTypeNode.DescendantNodes() .OfType <LockStatementSyntax>() .First(o => o.SpanStart == lockSpanStart && o.Span.Length == lockSpanLength); var lockTransformedNode = new LockTransformationResult(lockData); transformedNode.TransformedLocks.Add(lockTransformedNode); rootTypeNode = rootTypeNode.ReplaceNode(lockNode, lockNode.WithAdditionalAnnotations(new SyntaxAnnotation(lockTransformedNode.Annotation))); } } foreach (var methodResult in typeResult.SpecialMethods) { var methodSpanStart = methodResult.GetNode().SpanStart - startRootTypeSpan; var methodSpanLength = methodResult.GetNode().Span.Length; var methodNode = rootTypeNode.DescendantNodes() .OfType <BaseMethodDeclarationSyntax>() .First(o => o.SpanStart == methodSpanStart && o.Span.Length == methodSpanLength); var transformedNode = new FunctionTransformationResult(methodResult); transformResult.TransformedSpecialMethods.Add(transformedNode); rootTypeNode = rootTypeNode.ReplaceNode(methodNode, methodNode.WithAdditionalAnnotations(new SyntaxAnnotation(transformedNode.Annotation))); } foreach (var propertyResult in typeResult.Properties) { var spanStart = propertyResult.Node.SpanStart - startRootTypeSpan; var spanLength = propertyResult.Node.Span.Length; var node = rootTypeNode.DescendantNodes() .OfType <PropertyDeclarationSyntax>() .First(o => o.SpanStart == spanStart && o.Span.Length == spanLength); var transformedNode = new PropertyTransformationResult(propertyResult); transformResult.TransformedProperties.Add(transformedNode); rootTypeNode = rootTypeNode.ReplaceNode(node, node.WithAdditionalAnnotations(new SyntaxAnnotation(transformedNode.Annotation))); } } // Save the orignal node that was only annotated var originalAnnotatedNode = rootTypeNode; // Now we can start transforming the type. Start from the bottom in order to preserve replaced nested types foreach (var transformResult in rootTransformResult.GetSelfAndDescendantTransformedTypes().OrderByDescending(o => o.OriginalNode.SpanStart)) { var typeResult = transformResult.AnalyzationResult; // Add partial keyword on the original node if not present if ((typeResult.Conversion == TypeConversion.Partial || onlyMissingMembers) && !typeResult.IsPartial) { if (rootTransformResult.OriginalModified == null) { rootTransformResult.OriginalModified = originalAnnotatedNode; } var typeNode = rootTransformResult.OriginalModified.GetAnnotatedNodes(transformResult.Annotation).OfType <TypeDeclarationSyntax>().First(); rootTransformResult.OriginalModified = rootTransformResult.OriginalModified.ReplaceNode(typeNode, typeNode.AddPartial()); } if (typeResult.Conversion == TypeConversion.Ignore || ( onlyMissingMembers && !typeResult.GetSelfAndDescendantsTypes().SelectMany(o => o.MethodsAndAccessors).Any(o => o.Missing) )) { rootTypeNode = rootTypeNode.RemoveNodeKeepDirectives(transformResult.Annotation, transformResult.LeadingWhitespaceTrivia, transformResult.EndOfLineTrivia); continue; } var memberWhitespace = Whitespace(transformResult.LeadingWhitespaceTrivia.ToFullString() + transformResult.IndentTrivia.ToFullString()); if (typeResult.Conversion == TypeConversion.Partial || onlyMissingMembers) { // First we need to remove ignored method var typeNode = rootTypeNode.GetAnnotatedNodes(transformResult.Annotation).OfType <TypeDeclarationSyntax>().First(); // We need to remove the attributes as they cannot be defined in both partial classes var newTypeNode = typeNode.AddPartial().WithoutAttributes(); // We need to remove all other members that are not methods, properties or types newTypeNode = newTypeNode.RemoveMembersKeepDirectives(o => !(o is BaseMethodDeclarationSyntax || o is TypeDeclarationSyntax || o is PropertyDeclarationSyntax || o is BaseFieldDeclarationSyntax), memberWhitespace, transformResult.EndOfLineTrivia); rootTypeNode = TransformTypeMembers(namespaceMetadata, onlyMissingMembers, transformResult, newTypeNode, memberWhitespace, rootTypeNode, typeNode); } // If the root type has to be a new type then all nested types have to be new types else if (typeResult.Conversion == TypeConversion.NewType || typeResult.Conversion == TypeConversion.Copy) { var typeNode = rootTypeNode.GetAnnotatedNodes(transformResult.Annotation).OfType <TypeDeclarationSyntax>().First(); var identifierToken = typeNode.ChildTokens().First(o => o.IsKind(SyntaxKind.IdentifierToken)); var newTypeNode = typeResult.Conversion == TypeConversion.NewType ? typeNode.ReplaceToken(identifierToken, Identifier(identifierToken.ValueText + "Async").WithTriviaFrom(identifierToken)) : typeNode; rootTypeNode = TransformTypeMembers(namespaceMetadata, onlyMissingMembers, transformResult, newTypeNode, memberWhitespace, rootTypeNode, typeNode); } } rootTransformResult.Transformed = rootTypeNode; return(rootTransformResult); }
internal FieldTransformationResult TransformField( BaseFieldDeclarationSyntax fieldNode, bool canCopy, FieldTransformationResult result, ITypeTransformationMetadata typeMetadata, INamespaceTransformationMetadata namespaceMetadata) { var analyzeResult = result.AnalyzationResult; var startRootSpan = analyzeResult.Node.SpanStart; // Calculate whitespace method trivias result.EndOfLineTrivia = fieldNode.GetEndOfLine(); result.LeadingWhitespaceTrivia = fieldNode.GetLeadingWhitespace(); result.IndentTrivia = fieldNode.GetIndent(result.LeadingWhitespaceTrivia, typeMetadata.LeadingWhitespaceTrivia); if (analyzeResult.Variables.All(o => o.Conversion == FieldVariableConversion.Ignore || o.Conversion == FieldVariableConversion.Copy && !canCopy)) { return(result); } fieldNode = fieldNode.WithAdditionalAnnotations(new SyntaxAnnotation(result.Annotation)); startRootSpan -= fieldNode.SpanStart; // First we need to annotate nodes that will be modified in order to find them later on. // We cannot rely on spans after the first modification as they will change var typeReferencesAnnotations = new List <string>(); foreach (var typeReference in analyzeResult.TypeReferences.Where(o => o.TypeAnalyzationResult.Conversion == TypeConversion.NewType)) { var reference = typeReference.ReferenceLocation; var refSpanStart = reference.Location.SourceSpan.Start - startRootSpan; var nameNode = fieldNode.GetSimpleName(refSpanStart, reference.Location.SourceSpan.Length, typeReference.IsCref); var annotation = Guid.NewGuid().ToString(); fieldNode = fieldNode.ReplaceNode(nameNode, nameNode.WithAdditionalAnnotations(new SyntaxAnnotation(annotation))); typeReferencesAnnotations.Add(annotation); } foreach (var variableResult in analyzeResult.Variables) { var spanStart = variableResult.Node.SpanStart - startRootSpan; var spanLength = variableResult.Node.Span.Length; var accessorNode = fieldNode.DescendantNodes() .First(o => o.SpanStart == spanStart && o.Span.Length == spanLength); var transformedNode = new FieldVariableTransformationResult(variableResult); result.TransformedVariables.Add(transformedNode); fieldNode = fieldNode.ReplaceNode(accessorNode, accessorNode.WithAdditionalAnnotations(new SyntaxAnnotation(transformedNode.Annotation))); } // Modify references foreach (var refAnnotation in typeReferencesAnnotations) { var nameNode = fieldNode.GetAnnotatedNodes(refAnnotation).OfType <SimpleNameSyntax>().First(); fieldNode = fieldNode .ReplaceNode(nameNode, nameNode.WithIdentifier(Identifier(nameNode.Identifier.Value + "Async").WithTriviaFrom(nameNode.Identifier))); } foreach (var fieldVariableResult in result.TransformedVariables.OrderByDescending(o => o.OriginalStartSpan)) { var variableNode = (VariableDeclaratorSyntax)fieldNode.GetAnnotatedNodes(fieldVariableResult.Annotation) .First(); var variableTransformResult = TransformFieldVariable(variableNode, fieldVariableResult, canCopy); fieldNode = variableTransformResult.Transformed == null ? fieldNode.RemoveNode(variableNode, SyntaxRemoveOptions.KeepUnbalancedDirectives) : fieldNode.ReplaceNode(variableNode, variableTransformResult.Transformed); } result.Transformed = fieldNode; return(result); }