internal static EnumDeclarationSyntax AddEnumMemberTo(EnumDeclarationSyntax destination, IFieldSymbol enumMember, CodeGenerationOptions options)
{
var members = new List<SyntaxNodeOrToken>();
members.AddRange(destination.Members.GetWithSeparators());
var member = GenerateEnumMemberDeclaration(enumMember, destination, options);
if (members.Count == 0)
{
members.Add(member);
}
else if (members.LastOrDefault().CSharpKind() == SyntaxKind.CommaToken)
{
members.Add(member);
members.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
else
{
var lastMember = members.Last();
var trailingTrivia = lastMember.GetTrailingTrivia();
members[members.Count - 1] = lastMember.WithTrailingTrivia();
members.Add(SyntaxFactory.Token(SyntaxKind.CommaToken).WithTrailingTrivia(trailingTrivia));
members.Add(member);
}
return destination.EnsureOpenAndCloseBraceTokens()
.WithMembers(SyntaxFactory.SeparatedList<EnumMemberDeclarationSyntax>(members));
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
EnumWalker walker = this.CreateSyntaxWalker<EnumWalker>(node);
walker.Visit(node);
this.Enums.Add(walker);
base.VisitEnumDeclaration(node);
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
if (compilation != null)
{
var type = compilation.GetSemanticModel(node.SyntaxTree).GetDeclaredSymbol(node);
types.Add(type);
}
typeDeclarations.Add(node);
base.VisitEnumDeclaration(node);
}
public static string EnumDeclaration(EnumDeclarationSyntax declaration)
{
Builder.Instance.EnumMapToNames.Clear();
var parsedAttributes = ParseAttributes(declaration.AttributeLists);
var output = declaration.GetLeadingTrivia().ToFullString();
output += parsedAttributes.Item1;
var nameToUse = parsedAttributes.Item2;
output +=
Builder.Instance.LanguageConvertEnum()
+ " "
+ (nameToUse ?? SyntaxTokenConvert(declaration.Identifier).TrimEnd());
//Get the value of the enum
foreach (var decl in declaration.ChildNodes().OfType <EnumMemberDeclarationSyntax>()
.Where(decl => decl.EqualsValue != null).Select(decl => decl.EqualsValue.Value))
{
if (decl.IsKind(SyntaxKind.StringLiteralExpression))
{
output += Builder.Instance.LanguageConvertEnumPostfix("String");
}
else if (decl.IsKind(SyntaxKind.CharacterLiteralExpression))
{
output += Builder.Instance.LanguageConvertEnumPostfix("Character");
}
else if (decl.IsKind(SyntaxKind.NumericLiteralExpression))
{
output += Builder.Instance.LanguageConvertEnumPostfix("Int");
}
else
{
continue;
}
break;
}
var outputMembers = declaration.Members.ConvertSeparatedSyntaxList(
separatorForced: Builder.Instance.LanguageEnumMemberSeparator()
).TrimEnd();
var outputEnumMapToName = Builder.Instance.LanguageConvertEnumMapToName();
output +=
" "
+ SyntaxTokenConvert(declaration.OpenBraceToken).TrimStart()
+ outputMembers
+ NewLine
+ outputEnumMapToName
+ SyntaxTokenConvert(declaration.CloseBraceToken);
return(output);
}
private int Compare(EnumDeclarationSyntax x, EnumDeclarationSyntax y)
{
if (EqualAccessibility(x, x.Modifiers, y, y.Modifiers, out var result))
{
if (_includeName)
{
EqualIdentifierName(x.Identifier, y.Identifier, out result);
}
}
return(result);
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
var typeSymbol = importer.model.GetDeclaredSymbol(node);
FAMIX.Type type = importer.EnsureType(typeSymbol);
currentTypeStack.Push(type);
importer.CreateSourceAnchor(type, node);
type.isStub = false;
base.VisitEnumDeclaration(node);
currentTypeStack.Pop();
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
var typeSymbol = semanticModel.GetDeclaredSymbol(node);
FAMIX.Type type = importer.EnsureType(typeSymbol, typeof(FAMIX.Enum));
node.Modifiers.ToList <SyntaxToken>().ForEach(token => type.Modifiers.Add(token.Text));
currentTypeStack.Push(type);
importer.CreateSourceAnchor(type, node);
type.isStub = false;
base.VisitEnumDeclaration(node);
currentTypeStack.Pop();
}
public static Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
CancellationToken cancellationToken)
{
var rewriter = new SyntaxRewriter(enumDeclaration);
SyntaxNode newNode = rewriter.Visit(enumDeclaration)
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken));
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
if (SkipInnerTypeDeclaration(node)) { return; }
WriteLine($"{node.EnumKeyword} {node.Identifier} {{");
nestingDepth++;
base.VisitEnumDeclaration(node);
nestingDepth--;
WriteLine("}");
}
private static async Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
IEnumerable <EnumMemberDeclarationSyntax> enumMembers,
bool keepCompositeValue,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = null;
if (keepCompositeValue)
{
semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
INamedTypeSymbol enumSymbol = semanticModel.GetDeclaredSymbol(enumDeclaration, cancellationToken);
keepCompositeValue = enumSymbol.HasAttribute(MetadataNames.System_FlagsAttribute);
}
IEnumerable <TextChange> textChanges = enumMembers
.Where(enumMember =>
{
ExpressionSyntax expression = enumMember.EqualsValue?.Value;
if (expression == null)
{
return(false);
}
if (keepCompositeValue &&
!(expression is LiteralExpressionSyntax))
{
IFieldSymbol fieldSymbol = semanticModel.GetDeclaredSymbol(enumMember, cancellationToken);
if (!fieldSymbol.HasConstantValue)
{
return(false);
}
ulong value = SymbolUtility.GetEnumValueAsUInt64(fieldSymbol.ConstantValue, fieldSymbol.ContainingType);
if (FlagsUtility <ulong> .Instance.IsComposite(value))
{
return(false);
}
}
return(true);
})
.Select(f => new TextChange(TextSpan.FromBounds(f.Identifier.Span.End, f.EqualsValue.Span.End), ""));
return(await document.WithTextChangesAsync(textChanges, cancellationToken).ConfigureAwait(false));
}
private static async Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
EnumMemberDeclarationSyntax newEnumMember,
int insertIndex,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
EnumDeclarationSyntax newNode = enumDeclaration.WithMembers(enumDeclaration.Members.Insert(insertIndex, newEnumMember));
return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
private static async Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
INamedTypeSymbol enumSymbol,
object value,
CancellationToken cancellationToken)
{
EnumMemberDeclarationSyntax newEnumMember = GenerateEnumHelper.CreateEnumMember(enumSymbol, "EnumMember", value);
EnumDeclarationSyntax newNode = enumDeclaration.AddMembers(newEnumMember);
return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
}
/// <inheritdoc/>
public IEnumDeclaration CreateEnumDeclaration(
string nameSpace,
IReadOnlyList <string> usingDirectives,
EnumDeclarationSyntax node,
string location)
{
return(new EnumDeclaration(
nameSpace,
node.Identifier.Text,
new ParserSyntaxNodeProvider <EnumDeclarationSyntax>(node),
usingDirectives,
location));
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
var currentNameSpace = this.nameSpace.Peek();
var currentUsingDirectives = this.usingDirectives.Peek();
var enumDeclaration = this.declarationFactory.CreateEnumDeclaration(
currentNameSpace,
currentUsingDirectives,
node,
this.location);
this.declarations.Add(enumDeclaration);
}
private EnumDeclarationSyntax HandleAccessibility(EnumDeclarationSyntax node)
{
var newNode = node;
var visibility = new Visibility(this.EnumInfo).Token;
if (visibility != SyntaxKind.None)
{
newNode = newNode.AddModifiers(SyntaxFactory.Token(visibility));
}
return(newNode);
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="node">対象Node</param>
/// <param name="semanticModel">対象ソースのsemanticModel</param>
/// <param name="parent">親IAnalyzeItem</param>
/// <param name="container">イベントコンテナ</param>
public ItemEnum(EnumDeclarationSyntax node, SemanticModel semanticModel, IAnalyzeItem parent, EventContainer container) : base(parent, node, semanticModel, container)
{
ItemType = ItemTypes.Enum;
// アイテムと初期値を取得
foreach (var member in node.Members)
{
var declaredSymbol = semanticModel.GetDeclaredSymbol(member) as IFieldSymbol;
var name = declaredSymbol.Name;
var value = declaredSymbol.ConstantValue;
Items.Add(name, value?.ToString());
}
}
private static Task <Document> RefactorAsync(
Document document,
EnumDeclarationSyntax enumDeclaration,
INamedTypeSymbol enumSymbol,
object value,
CancellationToken cancellationToken)
{
EnumMemberDeclarationSyntax newEnumMember = CreateEnumMember(enumSymbol, DefaultNames.EnumMember, value);
EnumDeclarationSyntax newNode = enumDeclaration.AddMembers(newEnumMember);
return(document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken));
}
static List <CGFDocument> ProcessDocuments(CGFParserReporter reporter, List <Microsoft.CodeAnalysis.Document> documents, Microsoft.CodeAnalysis.Project project)
{
using (reporter.CreateContextScope(CGFParserReporterContext.Type.Project, project.FilePath))
{
List <CGFDocument> documentsToProcess = new List <CGFDocument>();
foreach (Microsoft.CodeAnalysis.Document document in documents)
{
using (reporter.CreateContextScope(CGFParserReporterContext.Type.File, document.FilePath))
{
List <CGFTypeSymbol> typesToProcess = new List <CGFTypeSymbol>();
Microsoft.CodeAnalysis.SemanticModel semanticModel = document.GetSemanticModelAsync().Result;
Microsoft.CodeAnalysis.SyntaxTree syntaxTree = document.GetSyntaxTreeAsync().Result;
IEnumerable <Microsoft.CodeAnalysis.SyntaxNode> syntaxNodes = syntaxTree.GetRoot().DescendantNodes().Where(n => (n as ClassDeclarationSyntax) != null || (n as EnumDeclarationSyntax) != null);
foreach (Microsoft.CodeAnalysis.SyntaxNode node in syntaxNodes)
{
ClassDeclarationSyntax classSyntax = node as ClassDeclarationSyntax;
if (classSyntax != null)
{
Microsoft.CodeAnalysis.INamedTypeSymbol typeSymbol = semanticModel.GetDeclaredSymbol(classSyntax);
using (reporter.CreateContextScope(CGFParserReporterContext.Type.Type, typeSymbol.Name))
{
CGFTypeSymbol cgfTypeSymbol = CGFTypeSymbol.Parse(reporter, typeSymbol);
typesToProcess.Add(cgfTypeSymbol);
}
}
else
{
EnumDeclarationSyntax enumSyntax = node as EnumDeclarationSyntax;
Microsoft.CodeAnalysis.INamedTypeSymbol typeSymbol = semanticModel.GetDeclaredSymbol(enumSyntax);
using (reporter.CreateContextScope(CGFParserReporterContext.Type.Type, typeSymbol.Name))
{
CGFTypeSymbol cgfTypeSymbol = CGFTypeSymbol.Parse(reporter, typeSymbol);
typesToProcess.Add(cgfTypeSymbol);
}
}
}
if (typesToProcess.Count > 0)
{
CGFDocument cgfDocument = CGFDocument.Parse(reporter, document, typesToProcess);
documentsToProcess.Add(cgfDocument);
}
}
}
return(documentsToProcess);
}
}
public static NetEnum GetNetEnum(EnumDeclarationSyntax enumDeclaration)
{
var name = enumDeclaration.Identifier.ToString();
var a = new NetEnum
{
Attributes = GetAttributeList(enumDeclaration.AttributeLists),
IsPublic = IsPublic(enumDeclaration.Modifiers),
Name = name,
Enums = GetNetEnumValues(enumDeclaration.Members)
};
return(a);
}
private static void __Execute(atom.Trace context, int level, EnumDeclarationSyntax data, string file, bool isShowPrivate)
{
if (__IsEnabled(data, isShowPrivate))
{
context.
SetComment(__GetType(data, "enum"), HINT.DATA_TYPE).
SetUrl(file, __GetLine(data.GetLocation()), __GetPosition(data.GetLocation())).
Send(NAME.SOURCE.PREVIEW, NAME.TYPE.CLASS, level, __GetName(data, true));
foreach (var a_Context in data.Members.OfType <EnumMemberDeclarationSyntax>())
{
__Execute(context, level + 1, a_Context, file, isShowPrivate);
}
}
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
string modifier = GetVisibilityModifier(node.Modifiers);
modifier = "export";
Emit(string.Join(" ", modifier, "class", node.Identifier.Text));
str_lastEqualVal = "=0";
counter = 0;
using (IndentedBracketScope())
{
base.VisitEnumDeclaration(node);
}
}
public virtual void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
this.BeginDeclaration(typeof(Symbols.Enum), node);
try
{
this.Visit(node.AnnotationList);
this.Visit(node.Name);
this.Visit(node.EnumBody);
}
finally
{
this.EndDeclaration();
}
}
public CSharpSyntaxNode Convert(EnumDeclaration node)
{
EnumDeclarationSyntax csEnum = SyntaxFactory.EnumDeclaration(node.Name.Text);
csEnum = csEnum.AddModifiers(node.Modifiers.ToCsNodes <SyntaxToken>());
csEnum = csEnum.AddMembers(node.Members.ToCsNodes <EnumMemberDeclarationSyntax>());
if (node.JsDoc.Count > 0)
{
csEnum = csEnum.WithLeadingTrivia(SyntaxFactory.Trivia(node.JsDoc[0].ToCsNode <DocumentationCommentTriviaSyntax>()));
}
return(csEnum);
}
void ExportEnum(EnumDeclarationSyntax c)
{
string name = "";
string nameSpace = "";
NamespaceDeclarationSyntax namespaceDeclarationSyntax = c.Parent as NamespaceDeclarationSyntax;
if (namespaceDeclarationSyntax != null)
{
nameSpace = namespaceDeclarationSyntax.Name.ToString();
}
else
{
nameSpace = ModelData.GloableNamespaceName;
}
name = c.Identifier.Text;
if (step == ECompilerStet.ScanType)
{
type_list.Add(new ULTypeInfo());
types.Push(type_list[type_list.Count - 1]);
currentType.Namespace = nameSpace;
currentType.Name = name;
currentType.IsEnum = true;
ModelData.UpdateType(currentType);
}
else
{
types.Push(ModelData.FindTypeByFullName(nameSpace + "." + name));
}
if (step == ECompilerStet.ScanMember)
{
//导出所有变量
var virableNodes = c.ChildNodes().OfType <EnumMemberDeclarationSyntax>();
foreach (var v in virableNodes)
{
var dB_Member = new ULMemberInfo();
dB_Member.Name = v.Identifier.Text;
dB_Member.IsStatic = false;
dB_Member.DeclareTypeName = currentType.FullName;
dB_Member.MemberType = ULMemberInfo.EMemberType.Enum;
currentType.Members.Add(dB_Member);
}
}
types.Pop();
}
public static Task <Document> RefactorAsync(
Document document,
BaseTypeSyntax baseType,
CancellationToken cancellationToken)
{
var baseList = (BaseListSyntax)baseType.Parent;
var enumDeclaration = (EnumDeclarationSyntax)baseList.Parent;
EnumDeclarationSyntax newEnumDeclaration = enumDeclaration
.RemoveNode(GetNodeToRemove(baseType, baseList), SyntaxRemoveOptions.KeepExteriorTrivia)
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(enumDeclaration, newEnumDeclaration, cancellationToken));
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
var item = new EnumInfo
{
Identifier = node.Identifier.ToString(),
Items = node.Members.Select(val => new EnumInfoItem
{
Name = val.Identifier.ValueText,
Value = int.Parse(val.EqualsValue.Value.ToString())
})
};
Enums.Add(item);
}
public static EnumDeclarationSyntax ToBaseType(this EnumDeclarationSyntax syntax, EnumBaseType baseType)
{
if (baseType == EnumBaseType.None)
{
return(syntax.WithBaseList(null));
}
SyntaxKind keyword = enumBaseTypeMap[baseType];
PredefinedTypeSyntax typeSyntax = SyntaxFactory.PredefinedType(SyntaxFactory.Token(keyword));
SeparatedSyntaxList <BaseTypeSyntax> baseTypes =
SyntaxFactory.SingletonSeparatedList <BaseTypeSyntax>(SyntaxFactory.SimpleBaseType(typeSyntax));
return(syntax.WithBaseList(SyntaxFactory.BaseList(baseTypes)));
}
/// <summary>
/// Adds documentation header async.
/// </summary>
/// <param name="document">The document.</param>
/// <param name="root">The root.</param>
/// <param name="declarationSyntax">The declaration syntax.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A Document.</returns>
private async Task <Document> AddDocumentationHeaderAsync(Document document, SyntaxNode root, EnumDeclarationSyntax declarationSyntax, CancellationToken cancellationToken)
{
SyntaxTriviaList leadingTrivia = declarationSyntax.GetLeadingTrivia();
string comment = CommentHelper.CreateEnumComment(declarationSyntax.Identifier.ValueText);
DocumentationCommentTriviaSyntax commentTrivia = await Task.Run(() => DocumentationHeaderHelper.CreateOnlySummaryDocumentationCommentTrivia(comment), cancellationToken);
SyntaxTriviaList newLeadingTrivia = leadingTrivia.Insert(leadingTrivia.Count - 1, SyntaxFactory.Trivia(commentTrivia));
EnumDeclarationSyntax newDeclaration = declarationSyntax.WithLeadingTrivia(newLeadingTrivia);
SyntaxNode newRoot = root.ReplaceNode(declarationSyntax, newDeclaration);
return(document.WithSyntaxRoot(newRoot));
}
/// <summary>
/// Add the attribute list to the <see cref="EnumDeclarationSyntax"/>.
/// </summary>
/// <param name="member">The <see cref="EnumDeclarationSyntax"/>.</param>
/// <param name="attributeList">The <see cref="AttributeListSyntax"/>.</param>
/// <returns>The <paramref name="member"/> with <paramref name="attributeList"/> added.</returns>
public static EnumDeclarationSyntax WithAttributeList(this EnumDeclarationSyntax member, AttributeListSyntax attributeList)
{
if (member is null)
{
throw new System.ArgumentNullException(nameof(member));
}
if (attributeList is null)
{
throw new System.ArgumentNullException(nameof(attributeList));
}
return(member.WithAttributeLists(member.AttributeLists.Add(attributeList)));
}
/// <summary>
/// Add <paramref name="text"/> as attribute list to <paramref name="member"/>.
/// </summary>
/// <param name="member">The <see cref="EnumDeclarationSyntax"/>.</param>
/// <param name="text">
/// The attribute text including start and end [].
/// </param>
/// <param name="adjustLeadingWhitespace">If true leading whitespace is adjusted to match <paramref name="member"/>.</param>
/// <returns>The <paramref name="member"/> with docs in leading trivia.</returns>
public static EnumDeclarationSyntax WithAttributeListText(this EnumDeclarationSyntax member, string text, bool adjustLeadingWhitespace = true)
{
if (member is null)
{
throw new System.ArgumentNullException(nameof(member));
}
if (text is null)
{
throw new System.ArgumentNullException(nameof(text));
}
return(member.WithAttributeList(Parse.AttributeList(text, adjustLeadingWhitespace ? member.LeadingWhitespace() : null)));
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
VisitAttributeLists(node.AttributeLists);
if (IsAnyNodeConst)
{
foreach (EnumMemberDeclarationSyntax member in node.Members)
{
Visit(member);
}
}
//base.VisitEnumDeclaration(node);
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
var name = node.Identifier.ToString();
if (node.Parent is ClassDeclarationSyntax)
{
base.VisitEnumDeclaration(node);
return;
}
output.AppendLine("enum " + name + "{");
output.IncreaseIndent();
base.VisitEnumDeclaration(node);
output.DecreaseIndent();
output.AppendLine("}");
}
/// <summary>
/// Processes an enum declaration. Also detects regions inside the element.
/// </summary>
public static void ProcessNode(EnumDeclarationSyntax node, ItemCollection itemCollection, int?index = null)
{
var item = new TreeViewItem
{
Header = new TreeElement(
node.Identifier.ToString(),
node.Span,
TreeImages.GetImage(ElementType.Enum, GetModifiers(node))),
IsExpanded = true
};
HandleChildrenWithRegions(node, item.Items);
AddOrInsert(itemCollection, item, index);
}
public EnumProcessor(EnumDeclarationSyntax syntax, Compilation compilation)
{
(_syntax, _compilation) = (syntax, compilation);
NamedTypeMap = new List <SpecialType>
{
SpecialType.System_Byte,
SpecialType.System_SByte,
SpecialType.System_Int16,
SpecialType.System_UInt16,
SpecialType.System_Int32,
SpecialType.System_UInt32,
SpecialType.System_Int64,
SpecialType.System_UInt64
}.ToDictionary(_compilation.GetSpecialType);
}
public static EnumMemberDeclarationSyntax GenerateEnumMemberDeclaration(
IFieldSymbol enumMember,
EnumDeclarationSyntax destinationOpt,
CodeGenerationOptions options)
{
var reusableSyntax = GetReuseableSyntaxNodeForSymbol<EnumMemberDeclarationSyntax>(enumMember, options);
if (reusableSyntax != null)
{
return reusableSyntax;
}
var value = CreateEnumMemberValue(destinationOpt, enumMember);
var member = SyntaxFactory.EnumMemberDeclaration(enumMember.Name.ToIdentifierToken())
.WithEqualsValue(value == null ? null : SyntaxFactory.EqualsValueClause(value: value));
return AddCleanupAnnotationsTo(
ConditionallyAddDocumentationCommentTo(member, enumMember, options));
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
Debug.Assert(currentScope == null);
DeclarationScope saveStaticInitScope = staticInitScope;
DeclarationScope saveInstanceInitScope = instanceInitScope;
staticInitScope = null;
instanceInitScope = null;
base.VisitEnumDeclaration(node);
staticInitScope = saveStaticInitScope;
instanceInitScope = saveInstanceInitScope;
Debug.Assert(currentScope == null);
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax 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.VisitEnumDeclaration(node);
CurrentClass = wasClass;
}
private SyntaxNode RegisterEnumDeclarationCodeFix(SyntaxNode syntaxRoot, EnumDeclarationSyntax node, IndentationOptions indentationOptions)
{
return this.ReformatElement(syntaxRoot, node, node.OpenBraceToken, node.CloseBraceToken, indentationOptions);
}
private void ClassifyUpdate(EnumDeclarationSyntax oldNode, EnumDeclarationSyntax newNode)
{
if (!SyntaxFactory.AreEquivalent(oldNode.Identifier, newNode.Identifier))
{
ReportError(RudeEditKind.Renamed);
return;
}
if (!SyntaxFactory.AreEquivalent(oldNode.Modifiers, newNode.Modifiers))
{
ReportError(RudeEditKind.ModifiersUpdate);
return;
}
if (!SyntaxFactory.AreEquivalent(oldNode.BaseList, newNode.BaseList))
{
ReportError(RudeEditKind.EnumUnderlyingTypeUpdate);
return;
}
// The list of members has been updated (separators added).
// We report a Rude Edit for each updated member.
}
/// <summary>
/// Initializes a new instance of the <see cref="EnumDeclaration"/> class.
/// </summary>
/// <param name="enumDeclarationNode"></param>
public EnumDeclaration(EnumDeclarationSyntax enumDeclarationNode)
: this(enumDeclarationNode, null)
{
}
public virtual void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
DefaultVisit(node);
}
public override SyntaxNode VisitEnumDeclaration(EnumDeclarationSyntax node)
{
return VisitMemberDeclaration(node, base.VisitEnumDeclaration(node));
}
private static ExpressionSyntax CreateEnumMemberValue(EnumDeclarationSyntax destinationOpt, IFieldSymbol enumMember)
{
var valueOpt = enumMember.ConstantValue is IConvertible
? (long?)IntegerUtilities.ToInt64(enumMember.ConstantValue)
: null;
if (valueOpt == null)
{
return null;
}
var value = valueOpt.Value;
if (destinationOpt != null)
{
if (destinationOpt.Members.Count == 0)
{
if (value == 0)
{
return null;
}
}
else
{
// Don't generate an initializer if no other members have them, and our value
// would be correctly inferred from our position.
if (destinationOpt.Members.Count == value &&
destinationOpt.Members.All(m => m.EqualsValue == null))
{
return null;
}
// Existing members, try to stay consistent with their style.
var lastMember = destinationOpt.Members.LastOrDefault(m => m.EqualsValue != null);
if (lastMember != null)
{
var lastExpression = lastMember.EqualsValue.Value;
if (lastExpression.CSharpKind() == SyntaxKind.LeftShiftExpression &&
IntegerUtilities.HasOneBitSet(value))
{
var binaryExpression = (BinaryExpressionSyntax)lastExpression;
if (binaryExpression.Left.CSharpKind() == SyntaxKind.NumericLiteralExpression)
{
var numericLiteral = (LiteralExpressionSyntax)binaryExpression.Left;
if (numericLiteral.Token.ValueText == "1")
{
// The user is left shifting ones, stick with that pattern
var shiftValue = IntegerUtilities.LogBase2(value);
return SyntaxFactory.BinaryExpression(
SyntaxKind.LeftShiftExpression,
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal("1", 1)),
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(shiftValue.ToString(), shiftValue)));
}
}
}
else if (lastExpression.CSharpKind() == SyntaxKind.NumericLiteralExpression)
{
var numericLiteral = (LiteralExpressionSyntax)lastExpression;
var numericToken = numericLiteral.Token;
var numericText = numericToken.ToString();
if (numericText.StartsWith("0x") || numericText.StartsWith("0X"))
{
// Hex
return SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression,
SyntaxFactory.Literal(numericText.Substring(0, 2) + value.ToString("X"), value));
}
}
}
}
}
var namedType = enumMember.Type as INamedTypeSymbol;
var underlyingType = namedType != null ? namedType.EnumUnderlyingType : null;
return ExpressionGenerator.GenerateNonEnumValueExpression(
underlyingType,
enumMember.ConstantValue,
canUseFieldReference: true);
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
base.VisitEnumDeclaration(node);
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
CheckXmlDocForErrors(node, semanticModel.GetDeclaredSymbol(node));
base.VisitEnumDeclaration(node);
}
public static EnumDeclarationSyntax EnumDeclaration(string identifier = null)
{
var result = new EnumDeclarationSyntax();
result.Identifier = identifier;
return result;
}
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
var symbol = model.GetDeclaredSymbol(node);
AddDeclaredItem(symbol, node);
base.VisitEnumDeclaration(node);
}
public static EnumDeclarationSyntax EnumDeclaration(IEnumerable<AttributeListSyntax> attributeLists = null, Modifiers modifiers = default(Modifiers), string identifier = null, BaseListSyntax baseList = null, IEnumerable<EnumMemberDeclarationSyntax> members = null)
{
var result = new EnumDeclarationSyntax();
if (attributeLists != null)
result.AttributeLists.AddRange(attributeLists);
result.Modifiers = modifiers;
result.Identifier = identifier;
result.BaseList = baseList;
if (members != null)
result.Members.AddRange(members);
return result;
}
public override SyntaxNode VisitEnumDeclaration(EnumDeclarationSyntax node)
{
if (!_template.SupportEnum)
{
this.AppendCompileIssue(node, IssueType.Error, IssueId.EnumNotSupport, _template.Name);
}
else
{
var info = _semanticModel.GetDeclaredSymbol(node);
string enumName = info.GetTypeSymbolName();
var enumTemplate = _template.CreateEnumTemplate();
enumTemplate.Assign("enum", enumName);
_output.Write(node, enumTemplate.GetBeginString());
_output.IncreaseIndent();
var count = 0;
foreach (var member in node.Members)
{
Visit(member);
count++;
if (count != node.Members.Count)
{
_output.TrivialWriteLine(',');
}
}
_output.DecreaseIndent();
_output.TrivialWriteLine(enumTemplate.GetEndString());
if (node.BaseList != null)
{
this.AppendCompileIssue(node, IssueType.Error, IssueId.EnumInheritNotSupport);
}
}
return node;
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
var enumWalker = EnumDefinitionASTWalker.Create(node, this.CreateWalkingContext(), this.semanticModel);
var translationUnit = enumWalker.Walk();
this.module.AddClass(translationUnit);
this.InvokeEnumDeclarationVisited(this, new WalkerEventArgs());
}
private static EnumDeclarationSyntax AddLineFeedsToCommas(EnumDeclarationSyntax enumDeclarationSyntax)
{
var none = new SyntaxToken();
var trailingTriviaList = SyntaxTriviaList.Create(SyntaxFactory.ElasticCarriageReturnLineFeed);
Func<EnumDeclarationSyntax, SyntaxToken> next = enumSyntax => enumSyntax.ChildNodesAndTokens()
.Where(nodeOrToken => nodeOrToken.IsToken)
.Select(nodeOrToken => nodeOrToken.AsToken())
.FirstOrDefault(
token =>
token.Value.Equals(",") &&
(!token.HasTrailingTrivia || !token.TrailingTrivia.Any(SyntaxKind.EndOfLineTrivia)));
SyntaxToken current;
while ((current = next(enumDeclarationSyntax)) != none)
{
enumDeclarationSyntax = enumDeclarationSyntax.ReplaceToken(current,
SyntaxFactory.Identifier(SyntaxTriviaList.Empty, ",", trailingTriviaList)
);
}
return enumDeclarationSyntax;
}
private EnumNode GetEnumNode(EnumDeclarationSyntax EachEnum)
{
EnumNode enumnode = new EnumNode();
enumnode.EnumName = EachEnum.Identifier.ToString();
foreach (var member in EachEnum.Members)
{
enumnode.AddMember(member.Identifier.ToString());
}
return enumnode;
}
private static SyntaxNode HandleEnumDeclaration(EnumDeclarationSyntax node)
{
SyntaxToken triviaToken = node.EnumKeyword;
if (triviaToken.IsMissing)
{
return null;
}
SyntaxKind defaultVisibility = IsNestedType(node) ? SyntaxKind.PrivateKeyword : SyntaxKind.InternalKeyword;
SyntaxTokenList modifiers = DeclarationModifiersHelper.AddModifier(node.Modifiers, ref triviaToken, defaultVisibility);
return node
.WithEnumKeyword(triviaToken)
.WithModifiers(modifiers)
.WithoutFormatting();
}
/// <summary>
/// Traverse AST node that represents enumeration declaration
/// </summary>
/// <param name="node">AST node.</param>
public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
try
{
if (!node.Identifier.Span.IsEmpty)
{
var symbol = _sm.GetDeclaredSymbol(node);
if (!_defined.Contains(symbol))
{
_defined.Add(symbol);
var def = Def.For(symbol: symbol, type: "enum", name: symbol.Name).At(_path, node.Identifier.Span);
if (symbol.IsExported())
{
def.Exported = true;
}
AddDef(def, DocProcessor.ForClass(symbol));
}
}
base.VisitEnumDeclaration(node);
}
catch (Exception e)
{
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EnumDeclaration"/> class.
/// </summary>
/// <param name="enumDeclarationNode"></param>
/// <param name="semanticModel"></param>
public EnumDeclaration(EnumDeclarationSyntax enumDeclarationNode, SemanticModel semanticModel)
: base(enumDeclarationNode, semanticModel)
{
}
public static string EnumDeclaration(EnumDeclarationSyntax declaration)
{
var parsedAttributes = ParseAttributes(declaration.AttributeLists);
var output = parsedAttributes.Item1;
var nameToUse = parsedAttributes.Item2;
output += "enum " + (nameToUse ?? declaration.Identifier.Text);
//Get the value of the enum
foreach (var decl in declaration.ChildNodes().OfType<EnumMemberDeclarationSyntax>().Where(decl => decl.EqualsValue != null).Select(decl => decl.EqualsValue.Value))
{
if (decl.IsKind(SyntaxKind.StringLiteralExpression))
{
output += ": String";
}
else if (decl.IsKind(SyntaxKind.CharacterLiteralExpression))
{
output += ": Character";
}
else if (decl.IsKind(SyntaxKind.NumericLiteralExpression))
{
output += ": Int";
}
else
{
continue;
}
break;
}
return output + " {" + NewLine +
string.Join("," + NewLine, declaration.Members.Select(SyntaxNode)) + NewLine +
"}" + NewLine + NewLine;
}
public EnumDeclarationTranslation(EnumDeclarationSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Members = syntax.Members.Get<EnumMemberDeclarationSyntax, EnumMemberDeclarationTranslation>(this);
Members.IsNewLine = true;
}
public void VisitEnumDeclaration(EnumDeclarationSyntax node)
{
VisitBaseTypeDeclaration(node);
_writer.PushBraceFormatting(_writer.Configuration.BracesLayout.TypeAndNamespaceDeclaration);
if (node.Members.Count == 0)
{
_writer.EmptyBlock(_writer.Configuration.BlankLines.InsideType);
}
else
{
_writer.BeginBlock();
_writer.WriteLine(_writer.Configuration.BlankLines.InsideType);
for (int i = 0; i < node.Members.Count; i++)
{
if (i > 0)
_writer.WriteLine(_writer.Configuration.BlankLines.AroundField);
node.Members[i].Accept(this);
}
_writer.WriteLine(_writer.Configuration.BlankLines.InsideType);
_writer.EndBlock();
}
_writer.PopBraceFormatting();
WriteTrailingTrivia(node);
}
public override void VisitEnumDeclaration (EnumDeclarationSyntax node)
{
VisitBody (node);
}
public override SyntaxNode VisitEnumDeclaration(EnumDeclarationSyntax node)
{
if (node == null)
return null;
var symbol = m_model.GetDeclaredSymbol(node);
node = (EnumDeclarationSyntax)base.VisitEnumDeclaration(node);
if (!IsPrivateOrInternal(symbol.DeclaredAccessibility))
node = (EnumDeclarationSyntax)ApplyDocComment(node, symbol.GetDocumentationCommentId());
return node;
}
