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