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;
}
