public virtual void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
if (this.ThrowException)
{
throw (System.Exception) this.CreateException(enumMemberDeclaration);
}
}
public virtual void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
if (ThrowException)
{
throw (Exception)CreateException(enumMemberDeclaration);
}
}
public override IUnresolvedEntity VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration, object data)
{
DefaultUnresolvedField field = new DefaultUnresolvedField(currentTypeDefinition, enumMemberDeclaration.Name);
field.Region = field.BodyRegion = MakeRegion(enumMemberDeclaration);
ConvertAttributes(field.Attributes, enumMemberDeclaration.Attributes);
if (currentTypeDefinition.TypeParameters.Count == 0) {
field.ReturnType = currentTypeDefinition;
} else {
ITypeReference[] typeArgs = new ITypeReference[currentTypeDefinition.TypeParameters.Count];
for (int i = 0; i < typeArgs.Length; i++) {
typeArgs[i] = new TypeParameterReference(EntityType.TypeDefinition, i);
}
field.ReturnType = new ParameterizedTypeReference(currentTypeDefinition, typeArgs);
}
field.Accessibility = Accessibility.Public;
field.IsStatic = true;
if (!enumMemberDeclaration.Initializer.IsNull) {
field.ConstantValue = ConvertConstantValue(field.ReturnType, enumMemberDeclaration.Initializer);
} else {
DefaultUnresolvedField prevField = currentTypeDefinition.Members.LastOrDefault() as DefaultUnresolvedField;
if (prevField == null || prevField.ConstantValue == null) {
field.ConstantValue = ConvertConstantValue(field.ReturnType, new PrimitiveExpression(0));
} else {
field.ConstantValue = new IncrementConstantValue(prevField.ConstantValue);
}
}
currentTypeDefinition.Members.Add(field);
if (interningProvider != null) {
field.ApplyInterningProvider(interningProvider);
}
return field;
}
public IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
var expr = GetCreatePropertyOrFieldNode(context);
if (expr == null)
yield break;
if (!(expr is MemberReferenceExpression))
yield break;
var propertyName = CreatePropertyAction.GetPropertyName(expr);
if (propertyName == null)
yield break;
if (IsInvocationTarget(expr))
yield break;
var statement = expr.GetParent<Statement>();
if (statement == null)
yield break;
if (!(context.Resolve(expr).IsError))
yield break;
var guessedType = CreateFieldAction.GuessType(context, expr);
if (guessedType == null || guessedType.Kind != TypeKind.Enum)
yield break;
var state = context.GetResolverStateBefore(expr);
if (state.CurrentMember == null || state.CurrentTypeDefinition == null)
yield break;
yield return new CodeAction(context.TranslateString("Create enum value"), script => {
var decl = new EnumMemberDeclaration {
Name = propertyName
};
script.InsertWithCursor(context.TranslateString("Create enum value"), guessedType.GetDefinition (), decl);
});
}
TypeDeclaration CreateEnumDeclaration(AstType baseType, string enumName, List <VariableInitializer> variables, List <string> names, Dictionary <string, string> newNames)
{
TypeDeclaration generatedEnum = new TypeDeclaration();
generatedEnum.ClassType = ClassType.Enum;
generatedEnum.BaseTypes.Add(baseType.Clone());
generatedEnum.Name = enumName;
generatedEnum.Modifiers = GetCombinedModifier((Modifiers)variables.Select(variable => ((FieldDeclaration)variable.Parent).Modifiers).Aggregate(0, (prev, newModifier) => prev | (int)newModifier));
foreach (var variable in variables)
{
var generatedMember = new EnumMemberDeclaration();
generatedMember.Name = newNames[variable.Name];
var value = variable.Initializer.Clone();
foreach (var identifier in value.DescendantsAndSelf.OfType <IdentifierExpression>().Where(identifier => names.Contains(identifier.Identifier)))
{
var newIdentifier = new IdentifierExpression(newNames[identifier.Identifier]);
if (identifier == value)
{
value = newIdentifier;
break;
}
identifier.ReplaceWith(newIdentifier);
}
generatedMember.Initializer = value;
generatedEnum.Members.Add(generatedMember);
}
return(generatedEnum);
}
public void Render(CodeDom.CodeObject target, DesignObject designObject)
{
var enumeration = (Enumeration)designObject;
var enumCodeObject = new EnumerationDeclaration
{
Name = enumeration.Name
};
(target as CodeDom.Module).TypeDeclarations.Add(enumCodeObject);
enumCodeObject.Scope = enumeration.Scope.Convert();
OnRenderEnumDeclaration(enumCodeObject);
foreach (var member in enumeration.Values)
{
var memberDeclaration = new EnumMemberDeclaration
{
Name = member.Name,
Value = member.Value
};
OnRenderEnumMemberDeclaration(memberDeclaration);
enumCodeObject.Values.Add(memberDeclaration);
}
OnAfterRenderEnumDeclaration(enumCodeObject);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
Expression initializer = enumMemberDeclaration.Initializer;
if (enumMemberDeclaration.Initializer.IsNull)
{
initializer = new PrimitiveExpression(++this.CurrentType.LastEnumValue);
}
else
{
var rr = this.Resolver.ResolveNode(enumMemberDeclaration.Initializer, null) as ConstantResolveResult;
if (rr != null)
{
initializer = new PrimitiveExpression(rr.ConstantValue);
this.CurrentType.LastEnumValue = (int)rr.ConstantValue;
}
}
this.CurrentType.StaticConfig.Fields.Add(new TypeConfigItem
{
Name = enumMemberDeclaration.Name,
Entity = enumMemberDeclaration,
Initializer = initializer
});
}
public override object VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration, object data)
{
if(!enumMemberDeclaration.Initializer.IsNull)
{
UnlockWith(enumMemberDeclaration.Initializer);
}
return base.VisitEnumMemberDeclaration(enumMemberDeclaration, data);
}
public void EnumWithInitializer()
{
TypeDeclaration td = ParseUtilCSharp.ParseGlobal <TypeDeclaration>("enum MyEnum { Val1 = 10 }");
EnumMemberDeclaration member = (EnumMemberDeclaration)td.Members.Single();
Assert.AreEqual("Val1", member.Name);
Assert.AreEqual(10, ((PrimitiveExpression)member.Initializer).Value);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
if (!_ignoredMembers.Contains(enumMemberDeclaration.Name))
{
_currentMembers.Peek().Item2.Add(new NameNode(enumMemberDeclaration.Name, enumMemberDeclaration));
}
base.VisitEnumMemberDeclaration(enumMemberDeclaration);
}
public override object VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration, object data)
{
if (!enumMemberDeclaration.Initializer.IsNull)
{
UnlockWith(enumMemberDeclaration.Initializer);
}
return(base.VisitEnumMemberDeclaration(enumMemberDeclaration, data));
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration ed)
{
ModelV2.Code.Enum e = (ModelV2.Code.Enum) GetDeclarationFor(ed);
string[] keyValue = ed.GetText().Split('=');
e.Values.Add(new KeyValuePair<string,string>(keyValue[0], (keyValue.Length == 2) ? keyValue[1] : ""));
// call base
base.VisitEnumMemberDeclaration(ed);
}
/// <summary>
/// Creates a <see cref="EnumMemberTranslationUnitFactory"/>.
/// </summary>
/// <returns>A <see cref="EnumMemberTranslationUnitFactory"/>.</returns>
public ITranslationUnit Create()
{
var helper = new EnumMemberDeclaration(this.Node as EnumMemberDeclarationSyntax, this.SemanticModel);
var enumMemberDeclaration = this.CreateTranslationUnit(IdentifierTranslationUnit.Create(helper.Name),
helper.Value != null ? new ExpressionTranslationUnitBuilder(helper.Value, this.SemanticModel).Build() : null)
as EnumMemberTranslationUnit;
return(enumMemberDeclaration);
}
void HandleVisitorEnumMemberDeclarationVisited(EnumMemberDeclaration node, InspectionData data)
{
foreach (var rule in policy.Rules)
{
if (rule.CheckEnumMember(node, data))
{
return;
}
}
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var expr = GetCreatePropertyOrFieldNode(context);
if (expr == null)
{
yield break;
}
if (!(expr is MemberReferenceExpression))
{
yield break;
}
var propertyName = CreatePropertyAction.GetPropertyName(expr);
if (propertyName == null)
{
yield break;
}
if (IsInvocationTarget(expr))
{
yield break;
}
var statement = expr.GetParent <Statement>();
if (statement == null)
{
yield break;
}
if (!(context.Resolve(expr).IsError))
{
yield break;
}
var guessedType = TypeGuessing.GuessType(context, expr);
if (guessedType == null || guessedType.Kind != TypeKind.Enum)
{
yield break;
}
var state = context.GetResolverStateBefore(expr);
if (state.CurrentMember == null || state.CurrentTypeDefinition == null)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Create enum value"), script => {
var decl = new EnumMemberDeclaration {
Name = propertyName
};
script.InsertWithCursor(context.TranslateString("Create enum value"), guessedType.GetDefinition(), (s, c) => decl);
}, expr)
{
Severity = ICSharpCode.NRefactory.Refactoring.Severity.Error
});
}
/// <inheritdoc/>
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
Formatter.AppendIndentedName(enumMemberDeclaration.NameToken.Name);
Formatter.Append("_");
Formatter.Append(EnumName);
if (!enumMemberDeclaration.Initializer.IsNull)
{
Formatter.Append(" = ");
enumMemberDeclaration.Initializer.AcceptVisitor(this);
}
}
public UnifiedElement VisitEnumMemberDeclaration(
EnumMemberDeclaration dec, object data)
{
var attrs = dec.Attributes.AcceptVisitorAsAttrs(this, data);
var mods = LookupModifiers(dec.Modifiers);
var name = UnifiedIdentifier.CreateVariable(dec.Name);
var value = dec.Initializer.TryAcceptForExpression(this);
return(UnifiedVariableDefinition.Create(
attrs, mods, /*no type*/ null, name, value,
/*no args*/ null, /*no bit field*/ null, /*no body*/ null));
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
Expression initializer = enumMemberDeclaration.Initializer;
if (enumMemberDeclaration.Initializer.IsNull)
{
initializer = new PrimitiveExpression(this.CurrentType.LastEnumValue);
}
this.CurrentType.StaticConfig.Fields.Add(new TypeConfigItem
{
Name = enumMemberDeclaration.Name,
Entity = enumMemberDeclaration,
Initializer = initializer
});
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
Expression initializer = enumMemberDeclaration.Initializer;
if (enumMemberDeclaration.Initializer.IsNull)
{
initializer = new PrimitiveExpression(this.CurrentType.LastEnumValue);
}
this.CurrentType.StaticConfig.Fields.Add(new TypeConfigItem
{
Name = enumMemberDeclaration.Name,
Entity = enumMemberDeclaration,
Initializer = initializer
});
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
Expression initializer = enumMemberDeclaration.Initializer;
if (enumMemberDeclaration.Initializer.IsNull)
{
dynamic i = this.CurrentType.LastEnumValue;
if (this.CurrentType.Type.GetDefinition().Attributes.Any(attr => attr.AttributeType.FullName == "System.FlagsAttribute"))
{
if (i <= 0)
{
this.CurrentType.LastEnumValue = 1;
}
else
{
this.CurrentType.LastEnumValue = i * 2;
}
initializer = new PrimitiveExpression(this.CurrentType.LastEnumValue);
}
else
{
++i;
this.CurrentType.LastEnumValue = i;
initializer = new PrimitiveExpression(this.CurrentType.LastEnumValue);
}
}
else
{
var rr = this.Resolver.ResolveNode(enumMemberDeclaration.Initializer, null) as ConstantResolveResult;
if (rr != null)
{
initializer = new PrimitiveExpression(rr.ConstantValue);
this.CurrentType.LastEnumValue = rr.ConstantValue;
}
}
this.CurrentType.StaticConfig.Fields.Add(new TypeConfigItem
{
Name = enumMemberDeclaration.Name,
Entity = enumMemberDeclaration,
Initializer = initializer
});
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
Expression initializer = enumMemberDeclaration.Initializer;
if (enumMemberDeclaration.Initializer.IsNull)
{
if (this.CurrentType.Type.GetDefinition().Attributes.Any(attr => attr.AttributeType.FullName == "System.FlagsAttribute"))
{
if (this.CurrentType.LastEnumValue <= 0)
{
this.CurrentType.LastEnumValue = 1;
}
else
{
this.CurrentType.LastEnumValue *= 2;
}
initializer = new PrimitiveExpression(this.CurrentType.LastEnumValue);
}
else
{
initializer = new PrimitiveExpression(++this.CurrentType.LastEnumValue);
}
}
else
{
var rr = this.Resolver.ResolveNode(enumMemberDeclaration.Initializer, null) as ConstantResolveResult;
if (rr != null)
{
initializer = new PrimitiveExpression(rr.ConstantValue);
this.CurrentType.LastEnumValue = (int)rr.ConstantValue;
}
}
this.CurrentType.StaticConfig.Fields.Add(new TypeConfigItem
{
Name = enumMemberDeclaration.Name,
Entity = enumMemberDeclaration,
Initializer = initializer
});
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
Expression initializer = enumMemberDeclaration.Initializer;
if (enumMemberDeclaration.Initializer.IsNull)
{
initializer = new PrimitiveExpression(++this.CurrentType.LastEnumValue);
}
else
{
var rr = this.Resolver.ResolveNode(enumMemberDeclaration.Initializer, null) as ConstantResolveResult;
if (rr != null)
{
initializer = new PrimitiveExpression(rr.ConstantValue);
this.CurrentType.LastEnumValue = (int)rr.ConstantValue;
}
}
this.CurrentType.StaticConfig.Fields.Add(new TypeConfigItem
{
Name = enumMemberDeclaration.Name,
Entity = enumMemberDeclaration,
Initializer = initializer
});
}
public void VisitEnumMemberDeclaration(EnumMemberDeclaration node)
{
// Ensure all enum members have a value
if (node.Initializer.IsNull) {
node.Initializer = new PrimitiveExpression(nextEnumValue++);
} else {
var result = resolver.Resolve(node.Initializer) as ConstantResolveResult;
if (result != null && result.ConstantValue is int) {
node.Initializer = new PrimitiveExpression((int)result.ConstantValue);
nextEnumValue = (int)result.ConstantValue + 1;
} else {
NotSupported(node.Initializer);
}
}
VisitChildren(node);
}
public virtual TReturn Visit(EnumMemberDeclaration node, TParam param)
{
node.Type.Accept(this, param);
node.Initializer?.Accept(this, param);
return(DefaultReturn);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
Expression initializer = enumMemberDeclaration.Initializer;
var member = this.Resolver.ResolveNode(enumMemberDeclaration, null) as MemberResolveResult;
var initializerIsString = false;
if (member != null)
{
var validator = new Validator();
var enumMode = validator.EnumEmitMode(member.Member.DeclaringTypeDefinition);
if (enumMode >= 3 && enumMode < 7)
{
initializerIsString = true;
string enumStringName = member.Member.Name;
var attr = Helpers.GetInheritedAttribute(member.Member, Translator.Bridge_ASSEMBLY + ".NameAttribute");
if (attr != null)
{
var value = attr.PositionalArguments.First().ConstantValue;
string name = null;
if (value is string)
{
name = value.ToString();
}
else if (value is bool)
{
name = (bool)value ? Object.Net.Utilities.StringUtils.ToLowerCamelCase(member.Member.Name) : member.Member.Name;
}
if (member.Member.IsStatic && Emitter.IsReservedStaticName(name))
{
name = Helpers.ChangeReservedWord(name);
}
initializer = new PrimitiveExpression(name);
}
else
{
switch (enumMode)
{
case 3:
enumStringName = Object.Net.Utilities.StringUtils.ToLowerCamelCase(member.Member.Name);
break;
case 4:
break;
case 5:
enumStringName = enumStringName.ToLowerInvariant();
break;
case 6:
enumStringName = enumStringName.ToUpperInvariant();
break;
}
initializer = new PrimitiveExpression(enumStringName);
}
}
}
if (!initializerIsString)
{
if (enumMemberDeclaration.Initializer.IsNull)
{
dynamic i = this.CurrentType.LastEnumValue;
++i;
this.CurrentType.LastEnumValue = i;
if (member != null && member.Member.DeclaringTypeDefinition.EnumUnderlyingType.IsKnownType(KnownTypeCode.Int64))
{
initializer = new PrimitiveExpression(Convert.ToInt64(this.CurrentType.LastEnumValue));
}
else if (member != null && member.Member.DeclaringTypeDefinition.EnumUnderlyingType.IsKnownType(KnownTypeCode.UInt64))
{
initializer = new PrimitiveExpression(Convert.ToUInt64(this.CurrentType.LastEnumValue));
}
else
{
initializer = new PrimitiveExpression(this.CurrentType.LastEnumValue);
}
}
else
{
var rr = this.Resolver.ResolveNode(enumMemberDeclaration.Initializer, null) as ConstantResolveResult;
if (rr != null)
{
if (member != null && member.Member.DeclaringTypeDefinition.EnumUnderlyingType.IsKnownType(KnownTypeCode.Int64))
{
initializer = new PrimitiveExpression(Convert.ToInt64(rr.ConstantValue));
}
else if (member != null && member.Member.DeclaringTypeDefinition.EnumUnderlyingType.IsKnownType(KnownTypeCode.UInt64))
{
initializer = new PrimitiveExpression(Convert.ToUInt64(rr.ConstantValue));
}
else
{
initializer = new PrimitiveExpression(rr.ConstantValue);
}
this.CurrentType.LastEnumValue = rr.ConstantValue;
}
}
}
this.CurrentType.StaticConfig.Fields.Add(new TypeConfigItem
{
Name = enumMemberDeclaration.Name,
Entity = enumMemberDeclaration,
Initializer = initializer
});
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
VisitXmlChildren(enumMemberDeclaration);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
FixAttributesAndDocComment(enumMemberDeclaration);
var initializer = enumMemberDeclaration.Initializer;
if (!initializer.IsNull) {
ForceSpacesAround(enumMemberDeclaration.AssignToken, policy.SpaceAroundAssignment);
initializer.AcceptVisitor(this);
}
}
public void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
StartNode(enumMemberDeclaration);
WriteAttributes(enumMemberDeclaration.Attributes);
WriteModifiers(enumMemberDeclaration.ModifierTokens);
enumMemberDeclaration.NameToken.AcceptVisitor(this);
if (!enumMemberDeclaration.Initializer.IsNull) {
Space(policy.SpaceAroundAssignment);
WriteToken(Roles.Assign);
Space(policy.SpaceAroundAssignment);
enumMemberDeclaration.Initializer.AcceptVisitor(this);
}
EndNode(enumMemberDeclaration);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
FormatAttributedNode(enumMemberDeclaration);
base.VisitEnumMemberDeclaration(enumMemberDeclaration);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
FixAttributes(enumMemberDeclaration);
base.VisitEnumMemberDeclaration(enumMemberDeclaration);
}
public StringBuilder VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
throw new NotImplementedException();
}
public override void Visit (EnumMember em)
{
EnumMemberDeclaration newField = new EnumMemberDeclaration ();
VariableInitializer variable = new VariableInitializer ();
variable.AddChild (new Identifier (em.Name, Convert (em.Location)), AstNode.Roles.Identifier);
if (em.Initializer != null) {
variable.AddChild ((MonoDevelop.CSharp.Ast.Expression)em.Initializer.Accept (this), VariableInitializer.Roles.Expression);
}
newField.AddChild (variable, AstNode.Roles.Variable);
typeStack.Peek ().AddChild (newField, TypeDeclaration.MemberRole);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
throw NotSupportedToConsistency();
}
public JNode VisitEnumMemberDeclaration(EnumMemberDeclaration node)
{
throw new NotImplementedException();
}
public TypeDeclaration CreateType(TypeDefinition typeDef)
{
TypeDeclaration astType = new TypeDeclaration();
astType.Modifiers = ConvertModifiers(typeDef);
astType.Name = typeDef.Name;
if (typeDef.IsEnum) { // NB: Enum is value type
astType.ClassType = ClassType.Enum;
astType.Modifiers &= ~Modifiers.Sealed;
} else if (typeDef.IsValueType) {
astType.ClassType = ClassType.Struct;
astType.Modifiers &= ~Modifiers.Sealed;
} else if (typeDef.IsInterface) {
astType.ClassType = ClassType.Interface;
astType.Modifiers &= ~Modifiers.Abstract;
} else {
astType.ClassType = ClassType.Class;
}
// Nested types
foreach(TypeDefinition nestedTypeDef in typeDef.NestedTypes) {
astType.AddChild(CreateType(nestedTypeDef), TypeDeclaration.MemberRole);
}
if (typeDef.IsEnum) {
foreach (FieldDefinition field in typeDef.Fields) {
if (field.IsRuntimeSpecialName) {
// the value__ field
astType.AddChild(ConvertType(field.FieldType), TypeDeclaration.BaseTypeRole);
} else {
EnumMemberDeclaration enumMember = new EnumMemberDeclaration();
enumMember.Name = field.Name;
astType.AddChild(enumMember, TypeDeclaration.MemberRole);
}
}
} else {
// Base type
if (typeDef.BaseType != null && !typeDef.IsValueType && typeDef.BaseType.FullName != Constants.Object) {
astType.AddChild(ConvertType(typeDef.BaseType), TypeDeclaration.BaseTypeRole);
}
foreach (var i in typeDef.Interfaces)
astType.AddChild(ConvertType(i), TypeDeclaration.BaseTypeRole);
AddTypeMembers(astType, typeDef);
}
return astType;
}
public void TestEnumMemberDeclaration()
{
EnumMemberDeclaration node = new EnumMemberDeclaration(GetSymbolAtom(), GetExpression1(), Declaration.DeclarationFlags.Export, GetExpressionList(), DefaultLineInfo);
CheckSerializationRoundTrip(node);
}
public virtual void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
StartNode(enumMemberDeclaration);
WriteAttributes(enumMemberDeclaration.Attributes);
WriteModifiers(enumMemberDeclaration.ModifierTokens);
WriteIdentifier(enumMemberDeclaration.NameToken);
if (!enumMemberDeclaration.Initializer.IsNull) {
Space(policy.SpaceAroundAssignment);
WriteToken(Roles.Assign, BoxedTextColor.Operator);
Space(policy.SpaceAroundAssignment);
enumMemberDeclaration.Initializer.AcceptVisitor(this);
}
SaveDeclarationOffset();
EndNode(enumMemberDeclaration);
}
/// <inheritdoc/>
public virtual void VisitEnumMemberDeclaration(EnumMemberDeclaration syntax)
{
VisitNode(syntax);
}
public virtual void VisitEnumMemberDeclaration (EnumMemberDeclaration enumMemberDeclaration)
{
VisitChildren (enumMemberDeclaration);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
_currentEnumMembers.Add(new NameNode(enumMemberDeclaration.Name, enumMemberDeclaration));
base.VisitEnumMemberDeclaration(enumMemberDeclaration);
}
public void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
JsonObject declaration = CreateJsonEntityDeclaration(enumMemberDeclaration);
declaration.AddJsonValue("identifier", GetIdentifier(enumMemberDeclaration.NameToken));
if (!enumMemberDeclaration.Initializer.IsNull)
{
declaration.AddJsonValue("assign-role", GetKeyword(Roles.Assign));
declaration.AddJsonValue("initializer", GenExpression(enumMemberDeclaration.Initializer));
}
Push(declaration);
}
public void VisitEnumMemberDeclaration(EnumMemberDeclaration declaration)
{
Formatter.StartNode(declaration);
declaration.Declarator.AcceptVisitor(this);
Formatter.WriteToken(",");
Formatter.EndNode();
}
public override void Visit (EnumMember em)
{
EnumMemberDeclaration newField = new EnumMemberDeclaration ();
// TODO: attributes, 'new' modifier
newField.AddChild (new Identifier (em.Name, Convert (em.Location)), AstNode.Roles.Identifier);
if (em.Initializer != null) {
newField.AddChild ((Expression)em.Initializer.Accept (this), EnumMemberDeclaration.InitializerRole);
}
typeStack.Peek ().AddChild (newField, TypeDeclaration.MemberRole);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration node)
{
var resolved = resolver.Resolve(node) as MemberResolveResult;
if (resolved != null && resolved.Member.SymbolKind == SymbolKind.Field) {
context.enums[(IField)resolved.Member] = node;
}
}
public virtual void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
if (this.ThrowException)
{
throw (Exception)this.CreateException(enumMemberDeclaration);
}
}
public override void Visit (EnumMember em)
{
EnumMemberDeclaration newField = new EnumMemberDeclaration ();
VariableInitializer variable = new VariableInitializer ();
variable.AddChild (new Identifier (em.Name, Convert (em.Location)), AstNode.Roles.Identifier);
if (em.Initializer != null) {
var initializer = (AstNode)em.Initializer.Accept (this);
if (initializer != null)
variable.AddChild (initializer, AstNode.Roles.Initializer);
}
newField.AddChild (variable, AstNode.Roles.Initializer);
typeStack.Peek ().AddChild (newField, TypeDeclaration.Roles.Member);
}
public virtual TReturn Visit(EnumMemberDeclaration node, TParam param) => throw new NotImplementedException();
public EnumMemberInfo(EnumMemberDeclaration member)
{
Field = member;
Name = member.Name.Pascal();
}
public override void Visit (EnumMember em)
{
EnumMemberDeclaration newField = new EnumMemberDeclaration ();
AddAttributeSection (newField, em);
newField.AddChild (Identifier.Create (em.Name, Convert (em.Location)), AstNode.Roles.Identifier);
if (em.Initializer != null) {
newField.AddChild (new CSharpTokenNode (Convert (em.Initializer.Location), 1), EnumMemberDeclaration.Roles.Assign);
newField.AddChild ((Expression)em.Initializer.Accept (this), EnumMemberDeclaration.InitializerRole);
}
typeStack.Peek ().AddChild (newField, TypeDeclaration.MemberRole);
}
public TypeDeclaration CreateType(TypeDefinition typeDef)
{
TypeDefinition oldCurrentType = context.CurrentType;
context.CurrentType = typeDef;
TypeDeclaration astType = new TypeDeclaration();
ConvertAttributes(astType, typeDef);
astType.AddAnnotation(typeDef);
astType.Modifiers = ConvertModifiers(typeDef);
astType.Name = CleanName(typeDef.Name);
if (typeDef.IsEnum) { // NB: Enum is value type
astType.ClassType = ClassType.Enum;
astType.Modifiers &= ~Modifiers.Sealed;
} else if (typeDef.IsValueType) {
astType.ClassType = ClassType.Struct;
astType.Modifiers &= ~Modifiers.Sealed;
} else if (typeDef.IsInterface) {
astType.ClassType = ClassType.Interface;
astType.Modifiers &= ~Modifiers.Abstract;
} else {
astType.ClassType = ClassType.Class;
}
IEnumerable<GenericParameter> genericParameters = typeDef.GenericParameters;
if (typeDef.DeclaringType != null && typeDef.DeclaringType.HasGenericParameters)
genericParameters = genericParameters.Skip(typeDef.DeclaringType.GenericParameters.Count);
astType.TypeParameters.AddRange(MakeTypeParameters(genericParameters));
astType.Constraints.AddRange(MakeConstraints(genericParameters));
// Nested types
foreach(TypeDefinition nestedTypeDef in typeDef.NestedTypes) {
if (MemberIsHidden(nestedTypeDef, context.Settings))
continue;
astType.AddChild(CreateType(nestedTypeDef), TypeDeclaration.MemberRole);
}
if (typeDef.IsEnum) {
long expectedEnumMemberValue = 0;
bool forcePrintingInitializers = IsFlagsEnum(typeDef);
foreach (FieldDefinition field in typeDef.Fields) {
if (field.IsRuntimeSpecialName) {
// the value__ field
if (field.FieldType != typeDef.Module.TypeSystem.Int32) {
astType.AddChild(ConvertType(field.FieldType), TypeDeclaration.BaseTypeRole);
}
} else {
EnumMemberDeclaration enumMember = new EnumMemberDeclaration();
enumMember.Name = CleanName(field.Name);
long memberValue = (long)CSharpPrimitiveCast.Cast(TypeCode.Int64, field.Constant, false);
if (forcePrintingInitializers || memberValue != expectedEnumMemberValue) {
enumMember.AddChild(new PrimitiveExpression(field.Constant), EnumMemberDeclaration.InitializerRole);
}
expectedEnumMemberValue = memberValue + 1;
astType.AddChild(enumMember, TypeDeclaration.MemberRole);
}
}
} else {
// Base type
if (typeDef.BaseType != null && !typeDef.IsValueType && typeDef.BaseType.FullName != "System.Object") {
astType.AddChild(ConvertType(typeDef.BaseType), TypeDeclaration.BaseTypeRole);
}
foreach (var i in typeDef.Interfaces)
astType.AddChild(ConvertType(i), TypeDeclaration.BaseTypeRole);
AddTypeMembers(astType, typeDef);
}
context.CurrentType = oldCurrentType;
return astType;
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
base.VisitEnumMemberDeclaration(enumMemberDeclaration);
}
public StringBuilder VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration, int data)
{
throw new NotSupportedException();
}
void HandleVisitorEnumMemberDeclarationVisited (EnumMemberDeclaration node, InspectionData data)
{
foreach (var rule in policy.Rules) {
if (rule.CheckEnumMember (node, data))
return;
}
}
public override void VisitEnumDecl(EnumDecl decl, VisitKind visitKind)
{
if (visitKind != VisitKind.Enter || !decl.IsCompleteDefinition || decl.QualifiedName == null)
return;
if (!decl.QualifiedName.StartsWith ("Urho")) {
if (!decl.QualifiedName.ToLower ().Contains ("loopmode2d"))
return;
}
//Console.WriteLine($"VisitingType: {decl.QualifiedName}");
string typeName = RemapTypeName(decl.Name);
PushType(new TypeDeclaration
{
Name = typeName,
ClassType = ClassType.Enum,
Modifiers = Modifiers.Public
}, StringUtil.GetTypeComments(decl));
foreach (var constantDecl in decl.Decls<EnumConstantDecl>()) {
var valueName = RemapEnumName (typeName, constantDecl.Name);
switch (valueName) {
// LIST HERE ANY Values we want to skip
case "foo":
case null:
continue;
}
var x = new EnumMemberDeclaration();
var enumValue = new EnumMemberDeclaration { Name = valueName };
if (constantDecl.InitExpr != null) {
APSInt v;
constantDecl.InitExpr.EvaluateAsInt (decl.AstContext, out v);
var ul = v.GetLimitedValue ();
PrimitiveExpression value;
if ((ul & 0xffffffff) == ul)
value = new PrimitiveExpression ((int)ul);
else
throw new NotImplementedException ($"Got a {ul} value which will not fit on an int, you must manually handle this case in the generatorg");
enumValue.Initializer = value;
}
currentType.Members.Add(enumValue);
}
}
public override void Visit(EnumMember em)
{
var newField = new EnumMemberDeclaration();
AddAttributeSection(newField, em);
newField.AddChild(Identifier.Create(em.Name, Convert(em.Location)), Roles.Identifier);
if (em.Initializer != null) {
newField.AddChild(new CSharpTokenNode(Convert(em.Initializer.Location), Roles.Assign), Roles.Assign);
newField.AddChild((Expression)em.Initializer.Accept(this), EnumMemberDeclaration.InitializerRole);
}
//Console.WriteLine (newField.StartLocation +"-" + newField.EndLocation);
typeStack.Peek().AddChild(newField, Roles.TypeMemberRole);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
if (!_ignoredMembers.Contains(enumMemberDeclaration.Name))
_currentMembers.Peek().Item2.Add(new NameNode(enumMemberDeclaration.Name, enumMemberDeclaration));
base.VisitEnumMemberDeclaration(enumMemberDeclaration);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
base.VisitEnumMemberDeclaration(enumMemberDeclaration);
CheckName(enumMemberDeclaration, AffectedEntity.EnumMember, enumMemberDeclaration.NameToken, GetAccessibiltiy(enumMemberDeclaration, Modifiers.Private));
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration syntax)
{
_underlyingVisitor.VisitEnumMemberDeclaration(syntax);
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
base.VisitEnumMemberDeclaration(enumMemberDeclaration);
CheckName(enumMemberDeclaration, AffectedEntity.EnumMember, enumMemberDeclaration.NameToken, GetAccessibiltiy(enumMemberDeclaration, Modifiers.Private));
}
public override void VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
{
_currentEnumMembers.Add(new NameNode(enumMemberDeclaration.Name, enumMemberDeclaration));
base.VisitEnumMemberDeclaration(enumMemberDeclaration);
}
