private static StructDeclarationSyntax AddBaseType(StructDeclarationSyntax structDeclaration, BaseTypeSyntax baseType) { BaseListSyntax baseList = structDeclaration.BaseList; if (baseList == null) { baseList = BaseList(baseType); TypeParameterListSyntax typeParameterList = structDeclaration.TypeParameterList; if (typeParameterList != null) { return(structDeclaration .WithTypeParameterList(typeParameterList.WithoutTrailingTrivia()) .WithBaseList(baseList.WithTrailingTrivia(typeParameterList.GetTrailingTrivia()))); } else { SyntaxToken identifier = structDeclaration.Identifier; return(structDeclaration .WithIdentifier(identifier.WithoutTrailingTrivia()) .WithBaseList(baseList.WithTrailingTrivia(identifier.TrailingTrivia))); } } else { SeparatedSyntaxList <BaseTypeSyntax> types = baseList.Types; BaseTypeSyntax lastType = types.LastOrDefault(); if (lastType == null || (types.Count == 1 && types[0].IsMissing)) { SyntaxToken colonToken = baseList.ColonToken; baseType = baseType .WithLeadingTrivia(Space) .WithTrailingTrivia(colonToken.TrailingTrivia); baseList = baseList .WithColonToken(colonToken.WithoutTrailingTrivia()) .WithTypes(SingletonSeparatedList(baseType)); return(structDeclaration.WithBaseList(baseList)); } else { types = types .Replace(lastType, lastType.WithoutTrailingTrivia()) .Add(baseType.WithTrailingTrivia(lastType.GetTrailingTrivia())); return(structDeclaration.WithBaseList(baseList.WithTypes(types))); } } }
public static Doc Print(BaseListSyntax node) { return(Doc.Group( Doc.Indent( Doc.Line, Token.PrintWithSuffix(node.ColonToken, " "), Doc.Indent(SeparatedSyntaxList.Print(node.Types, Node.Print, Doc.Line)) ) )); }
internal static ClassDeclarationSyntax Class(string identifier, IEnumerable <SyntaxKind> keywords, string?baseType, IEnumerable <MemberDeclarationSyntax> members) { BaseListSyntax baseList = null; if (!string.IsNullOrWhiteSpace(baseType)) { baseList = SyntaxFactory.BaseList(SyntaxFactory.SingletonSeparatedList <BaseTypeSyntax>(SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName(baseType)))); } return(SyntaxFactory.ClassDeclaration(
public override SyntaxNode VisitBaseList(BaseListSyntax node) { _hasInterfaceList = true; var remainingMixinInterfaces = _mixinInterfaces .Select(x => x.GetReducedTypeName(_semantic, _positionOfChildClassInCode)) .Except(node.Types.Select(x => x.TypeName())) .Select(x => SimpleBaseType(IdentifierName(x))) .ToArray(); var result = node.AddTypes(remainingMixinInterfaces); return result; }
public static TypeDeclarationSyntax WithBaseList(this TypeDeclarationSyntax node, BaseListSyntax list) { switch (node.Kind()) { case SyntaxKind.ClassDeclaration: return ((ClassDeclarationSyntax)node).WithBaseList(list); case SyntaxKind.InterfaceDeclaration: return ((InterfaceDeclarationSyntax)node).WithBaseList(list); case SyntaxKind.StructDeclaration: return ((StructDeclarationSyntax)node).WithBaseList(list); } throw new NotImplementedException("WithBaseList " + node.Kind().ToString()); }
public void ReplaceBaseClass(ClassDeclarationSyntax classDeclaration, string baseType) { InitIfNeeded(); IdentifierNameSyntax identifierName = SyntaxFactory.IdentifierName(baseType); BaseTypeSyntax baseTypeSyntax = SyntaxFactory.SimpleBaseType(identifierName); SeparatedSyntaxList <BaseTypeSyntax> separatedSyntaxList = new SeparatedSyntaxList <BaseTypeSyntax>(); separatedSyntaxList = separatedSyntaxList.Add(baseTypeSyntax); BaseListSyntax baseSyntaxList = SyntaxFactory.BaseList(separatedSyntaxList); _formRoot = _formRoot.ReplaceNode(classDeclaration, classDeclaration.WithBaseList(baseSyntaxList)); _formTree = _formTree.WithRootAndOptions(_formRoot, _formTree.Options); }
private static SyntaxNode RemoveDeclaration(SyntaxNode root, BaseListSyntax baseList, int redundantIndex) { var newBaseList = baseList .RemoveNode(baseList.Types[redundantIndex], SyntaxRemoveOptions.KeepNoTrivia) .WithAdditionalAnnotations(Formatter.Annotation); if (newBaseList.Types.Count != 0) { return root.ReplaceNode(baseList, newBaseList); } var baseTypeHadLineEnding = HasLineEnding(baseList.Types[redundantIndex]); var colonHadLineEnding = HasLineEnding(baseList.ColonToken); var typeNameHadLineEnding = HasLineEnding(((BaseTypeDeclarationSyntax)baseList.Parent).Identifier); var annotation = new SyntaxAnnotation(); var newRoot = root.ReplaceNode( baseList.Parent, baseList.Parent.WithAdditionalAnnotations(annotation)); var declaration = (BaseTypeDeclarationSyntax)newRoot.GetAnnotatedNodes(annotation).First(); newRoot = newRoot.RemoveNode(declaration.BaseList, SyntaxRemoveOptions.KeepNoTrivia); declaration = (BaseTypeDeclarationSyntax)newRoot.GetAnnotatedNodes(annotation).First(); var needsNewLine = !typeNameHadLineEnding && (colonHadLineEnding || baseTypeHadLineEnding); if (needsNewLine) { var trivia = SyntaxFactory.TriviaList(); if (declaration.Identifier.HasTrailingTrivia) { trivia = declaration.Identifier.TrailingTrivia; } trivia = colonHadLineEnding ? trivia.Add(baseList.ColonToken.TrailingTrivia.Last()) : trivia.AddRange(baseList.Types[redundantIndex].GetTrailingTrivia()); newRoot = newRoot.ReplaceToken( declaration.Identifier, declaration.Identifier .WithTrailingTrivia(trivia)); } declaration = (BaseTypeDeclarationSyntax)newRoot.GetAnnotatedNodes(annotation).First(); return newRoot.ReplaceNode( declaration, declaration.WithoutAnnotations(annotation)); }
public static Doc Print(BaseListSyntax node) { return(Doc.Group( Doc.Indent( Doc.Line, Token.Print(node.ColonToken), " ", Doc.Align( 2, Doc.Concat(SeparatedSyntaxList.Print(node.Types, Node.Print, Doc.Line)) ) ) )); }
public static TypeDeclarationSyntax TypeDeclaration(SyntaxKind kind, SyntaxList<AttributeListSyntax> attributes, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, BaseListSyntax baseList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken) { switch (kind) { case SyntaxKind.ClassDeclaration: return SyntaxFactory.ClassDeclaration(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); case SyntaxKind.StructDeclaration: return SyntaxFactory.StructDeclaration(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); case SyntaxKind.InterfaceDeclaration: return SyntaxFactory.InterfaceDeclaration(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); default: throw new ArgumentException("kind"); } }
private static ImmutableArray <string> GetInheritanceNames( StringTable stringTable, BaseListSyntax baseList ) { if (baseList == null) { return(ImmutableArray <string> .Empty); } var builder = ArrayBuilder <string> .GetInstance(baseList.Types.Count); // It's not sufficient to just store the textual names we see in the inheritance list // of a type. For example if we have: // // using Y = X; // ... // using Z = Y; // ... // class C : Z // // It's insufficient to just state that 'C' derives from 'Z'. If we search for derived // types from 'B' we won't examine 'C'. To solve this, we keep track of the aliasing // that occurs in containing scopes. Then, when we're adding an inheritance name we // walk the alias maps and we also add any names that these names alias to. In the // above example we'd put Z, Y, and X in the inheritance names list for 'C'. // Each dictionary in this list is a mapping from alias name to the name of the thing // it aliases. Then, each scope with alias mapping gets its own entry in this list. // For the above example, we would produce: [{Z => Y}, {Y => X}] var aliasMaps = AllocateAliasMapList(); try { AddAliasMaps(baseList, aliasMaps); foreach (var baseType in baseList.Types) { AddInheritanceName(builder, baseType.Type, aliasMaps); } Intern(stringTable, builder); return(builder.ToImmutableAndFree()); } finally { FreeAliasMapList(aliasMaps); } }
private Doc PrintBaseListSyntax(BaseListSyntax node) { return(Group( Indent( Line, this.PrintSyntaxToken(node.ColonToken, " "), Indent( this.PrintSeparatedSyntaxList( node.Types, this.Print, Line ) ) ) )); }
private IEnumerable <string> ImplementedInterfacesFor(BaseListSyntax bases) { if (bases == null) { yield break; } foreach (var @base in bases.Types) { var info = Context.GetTypeInfo(@base.Type); if (info.Type.TypeKind == TypeKind.Interface) { var itfFQName = @base.DescendantTokens().OfType <SyntaxToken>().Aggregate("", (acc, curr) => acc + curr.ValueText); yield return(itfFQName); } } }
public static TypeDeclarationSyntax WithBaseList( this TypeDeclarationSyntax node, BaseListSyntax list) { switch (node.Kind()) { case SyntaxKind.ClassDeclaration: return(((ClassDeclarationSyntax)node).WithBaseList(list)); case SyntaxKind.InterfaceDeclaration: return(((InterfaceDeclarationSyntax)node).WithBaseList(list)); case SyntaxKind.StructDeclaration: return(((StructDeclarationSyntax)node).WithBaseList(list)); default: throw ExceptionUtilities.UnexpectedValue(node.Kind()); } }
private static void Analyze(SyntaxNodeAnalysisContext context, BaseListSyntax baseList, SyntaxToken previousToken) { SyntaxTriviaList trailingTrivia = previousToken.TrailingTrivia; if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(trailingTrivia)) { return; } if (!baseList.ColonToken.LeadingTrivia.IsEmptyOrWhitespace()) { return; } context.ReportDiagnostic( DiagnosticDescriptors.RemoveNewLineBeforeBaseList, Location.Create(baseList.SyntaxTree, new TextSpan(trailingTrivia.Last().SpanStart, 0))); }
private static MultiValueDictionary<INamedTypeSymbol, INamedTypeSymbol> GetImplementedInterfaceMappings( BaseListSyntax baseList, SemanticModel semanticModel) { return baseList.Types .Select(baseType => semanticModel.GetSymbolInfo(baseType.Type).Symbol as INamedTypeSymbol) .Where(symbol => symbol != null) .Select(symbol => new Tuple<INamedTypeSymbol, ICollection<INamedTypeSymbol>>(symbol, symbol.AllInterfaces)) .ToMultiValueDictionary(kv => kv.Item1, kv => kv.Item2); }
private void BindBaseList(BaseListSyntax baseList, Symbol parent, out ClassOrStructSymbol baseType, out List<InterfaceSymbol> baseInterfaces) { baseType = null; baseInterfaces = new List<InterfaceSymbol>(); if (baseList != null) { var baseTypeTemp = Bind(baseList.BaseType, x => BindType(x, parent)); switch (baseTypeTemp.TypeSymbol.Kind) { case SymbolKind.Class: case SymbolKind.Struct: baseType = (ClassOrStructSymbol) baseTypeTemp.TypeSymbol; break; case SymbolKind.Interface: baseInterfaces.Add((InterfaceSymbol) baseTypeTemp.TypeSymbol); break; } } }
public static TypeDeclarationSyntax WithBaseList( this TypeDeclarationSyntax node, BaseListSyntax list) { switch (node.Kind()) { case SyntaxKind.ClassDeclaration: return ((ClassDeclarationSyntax)node).WithBaseList(list); case SyntaxKind.InterfaceDeclaration: return ((InterfaceDeclarationSyntax)node).WithBaseList(list); case SyntaxKind.StructDeclaration: return ((StructDeclarationSyntax)node).WithBaseList(list); } throw new InvalidOperationException (); }
private static void CheckIfInterfaceIsRedundant(SyntaxNodeAnalysisContext c, BaseListSyntax baseList, Predicate<INamedTypeSymbol> additionalCheck) { var interfaceTypesWithAllInterfaces = GetImplementedInterfaceMappings(baseList, c.SemanticModel); for (int i = 0; i < baseList.Types.Count; i++) { var baseType = baseList.Types[i]; var interfaceType = c.SemanticModel.GetSymbolInfo(baseType.Type).Symbol as INamedTypeSymbol; if (interfaceType == null || interfaceType.TypeKind != TypeKind.Interface) { continue; } foreach (var interfaceTypeWithAllInterfaces in interfaceTypesWithAllInterfaces) { if (interfaceTypeWithAllInterfaces.Value.Contains(interfaceType) && !additionalCheck(interfaceType)) { var location = GetLocationWithToken(baseType.Type, baseList.Types); c.ReportDiagnostic(Diagnostic.Create(Rule, location, ImmutableDictionary<string, string>.Empty.Add(RedundantIndexKey, i.ToString()), string.Format(MessageAlreadyImplements, interfaceTypeWithAllInterfaces.Key.Name, interfaceType.Name))); break; } } } }
public virtual void VisitBaseList(BaseListSyntax node) { DefaultVisit(node); }
private static InterfaceDeclarationSyntax GenerateInterface(string name, IEnumerable<MethodDeclarationSyntax> methods, BaseListSyntax baseList) { InterfaceDeclarationSyntax generatedInterface = SF.InterfaceDeclaration(name).AddModifiers(SF.Token(SyntaxKind.PublicKeyword)).WithBaseList(baseList); foreach (var method in methods) { generatedInterface = generatedInterface.AddMembers(method.WithLeadingTrivia(SF.EndOfLine(""))); } return generatedInterface; }
/// <summary>Creates a new ClassDeclarationSyntax instance.</summary> public static ClassDeclarationSyntax ClassDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, BaseListSyntax baseList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken) { return SyntaxFactory.ClassDeclaration(attributeLists, modifiers, keyword, identifier, typeParameterList, null, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); }
/// <summary>Creates a new StructDeclarationSyntax instance.</summary> public static StructDeclarationSyntax StructDeclaration(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, BaseListSyntax baseList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxList<MemberDeclarationSyntax> members) { return SyntaxFactory.StructDeclaration(attributeLists, modifiers, identifier, typeParameterList, null, baseList, constraintClauses, members); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitBaseList(BaseListSyntax node) { this.OnNodeVisited(node); if (!this.traverseRootOnly) base.VisitBaseList(node); }
public void VisitBaseList(BaseListSyntax node) { if (node == null) throw new ArgumentNullException("node"); node.Validate(); if (_writer.Configuration.Spaces.Other.BeforeBaseTypesListColon) _writer.WriteSpace(); _writer.WriteSyntax(Syntax.Colon); if (_writer.Configuration.Spaces.Other.AfterBaseTypesListColon) _writer.WriteSpace(); if (_writer.Configuration.Other.AlignMultiLineConstructs.ListOfBaseClassesAndInterfaces) _writer.SetAlignmentBreak(true); _writer.PushWrapStyle(_writer.Configuration.LineBreaksAndWrapping.LineWrapping.WrapExtendsImplementsList); bool hadOne = false; foreach (var type in node.Types) { if (hadOne) _writer.WriteListSeparator(); else hadOne = true; type.Accept(this); } if (_writer.Configuration.Other.AlignMultiLineConstructs.ListOfBaseClassesAndInterfaces) _writer.SetAlignmentBreak(false); _writer.PopWrapStyle(); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitBaseList(BaseListSyntax node) { this.OnNodeVisited(node, this.type.IsInstanceOfType(node)); base.VisitBaseList(node); }
public BaseListTranslation(BaseListSyntax syntax, SyntaxTranslation parent) : base(syntax, parent) { Types = syntax.Types.Get<BaseTypeSyntax, BaseTypeTranslation>(this); }
private ImmutableArray<string> GetInheritanceNames(BaseListSyntax baseList) { if (baseList == null) { return ImmutableArray<string>.Empty; } var builder = ImmutableArray.CreateBuilder<string>(baseList.Types.Count); // It's not sufficient to just store the textual names we see in the inheritance list // of a type. For example if we have: // // using Y = X; // ... // using Z = Y; // ... // class C : Z // // It's insufficient to just state that 'C' derives from 'Z'. If we search for derived // types from 'B' we won't examine 'C'. To solve this, we keep track of the aliasing // that occurs in containing scopes. Then, when we're adding an inheritance name we // walk the alias maps and we also add any names that these names alias to. In the // above example we'd put Z, Y, and X in the inheritance names list for 'C'. // Each dictionary in this list is a mapping from alias name to the name of the thing // it aliases. Then, each scope with alias mapping gets its own entry in this list. // For the above example, we would produce: [{Z => Y}, {Y => X}] var aliasMaps = AllocateAliasMapList(); try { AddAliasMaps(baseList, aliasMaps); foreach (var baseType in baseList.Types) { AddInheritanceName(builder, baseType.Type, aliasMaps); } return builder.ToImmutable(); } finally { FreeAliasMapList(aliasMaps); } }
public StructDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, SyntaxToken keyword, SyntaxToken identifier, TypeParameterListSyntax typeParameterList, BaseListSyntax baseList, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses, SyntaxToken openBraceToken, SyntaxList<MemberDeclarationSyntax> members, SyntaxToken closeBraceToken, SyntaxToken semicolonToken) { return this.Update(attributeLists, modifiers, keyword, identifier, typeParameterList, this.ParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); }
public static BaseListSyntax RemoveBase(BaseListSyntax baseList, string baseName) { BaseTypeSyntax baseType = baseList.Types.First(type => type.Type.ToString() == baseName); return SF.BaseList(baseList.Types.Remove(baseType)); }
public static TypeDeclarationSyntax WithBaseList( this TypeDeclarationSyntax node, BaseListSyntax list) { switch (node.CSharpKind()) { case SyntaxKind.ClassDeclaration: return ((ClassDeclarationSyntax)node).WithBaseList(list); case SyntaxKind.InterfaceDeclaration: return ((InterfaceDeclarationSyntax)node).WithBaseList(list); case SyntaxKind.StructDeclaration: return ((StructDeclarationSyntax)node).WithBaseList(list); } throw Contract.Unreachable; }
public static BaseListSyntax AddBase(BaseListSyntax baseList, string baseName) { baseList = baseList.AddTypes(SF.SimpleBaseType(SF.IdentifierName(baseName))); return baseList; }