public static MethodVisibility GetVisibility(IPropertyReference value) { MethodVisibility visibility = MethodVisibility.Public; IPropertyDeclaration propertyDeclaration = value.Resolve(); if (propertyDeclaration != null) { IMethodReference setMethodReference = propertyDeclaration.SetMethod; IMethodDeclaration setMethod = (setMethodReference == null) ? null : setMethodReference.Resolve(); IMethodReference getMethodReference = propertyDeclaration.GetMethod; IMethodDeclaration getMethod = (getMethodReference == null) ? null : getMethodReference.Resolve(); if ((setMethod != null) && (getMethod != null)) { if (getMethod.Visibility == setMethod.Visibility) { visibility = getMethod.Visibility; } } else if (setMethod != null) { visibility = setMethod.Visibility; } else if (getMethod != null) { visibility = getMethod.Visibility; } } return(visibility); }
public static MethodVisibility GetVisibility(IPropertyReference value) { IMethodDeclaration getMethod = Helper.GetGetMethod(value); IMethodDeclaration setMethod = Helper.GetSetMethod(value); MethodVisibility visibility = MethodVisibility.Public; if ((setMethod != null) && (getMethod != null)) { if (getMethod.Visibility == setMethod.Visibility) { visibility = getMethod.Visibility; } } else if (setMethod != null) { visibility = setMethod.Visibility; } else if (getMethod != null) { visibility = getMethod.Visibility; } return(visibility); }
public static MethodVisibility GetVisibility(IPropertyReference value) { MethodVisibility result = MethodVisibility.Public; IPropertyDeclaration propertyDeclaration = value.Resolve(); if (propertyDeclaration != null) { IMethodReference setMethod = propertyDeclaration.SetMethod; IMethodDeclaration methodDeclaration = setMethod?.Resolve(); IMethodReference getMethod = propertyDeclaration.GetMethod; IMethodDeclaration methodDeclaration2 = getMethod?.Resolve(); if (methodDeclaration != null && methodDeclaration2 != null) { if (methodDeclaration2.Visibility == methodDeclaration.Visibility) { result = methodDeclaration2.Visibility; } } else if (methodDeclaration != null) { result = methodDeclaration.Visibility; } else if (methodDeclaration2 != null) { result = methodDeclaration2.Visibility; } } return(result); }
private void __WriteVisibilitySpecifier(MethodVisibility visibility, bool inline) { switch (visibility) { case MethodVisibility.PrivateScope: this.__WriteVisibilitySpecifier(AccessSpecifier.PrivateScope, inline); break; case MethodVisibility.Private: this.__WriteVisibilitySpecifier(AccessSpecifier.Private, inline); break; case MethodVisibility.FamilyAndAssembly: this.__WriteVisibilitySpecifier(AccessSpecifier.PrivateProtected, inline); break; case MethodVisibility.Assembly: this.__WriteVisibilitySpecifier(AccessSpecifier.Internal, inline); break; case MethodVisibility.Family: this.__WriteVisibilitySpecifier(AccessSpecifier.Protected, inline); break; case MethodVisibility.FamilyOrAssembly: this.__WriteVisibilitySpecifier(AccessSpecifier.InternalProtected, inline); break; case MethodVisibility.Public: this.__WriteVisibilitySpecifier(AccessSpecifier.Public, inline); break; } }
private static void GenerateMethod(StringBuilder sb, MethodVisibility methodVisibility, string methodName, string methodBody) { sb.AppendLine(@"#line 1 """""); sb.AppendFormat(" {0} {1}void {2}", methodVisibility.ToString().ToLowerInvariant(), methodVisibility == MethodVisibility.Private ? "static " : "", methodName); sb.AppendLine(); sb.AppendLine(" {"); sb.AppendLine(@"#line 1 """""); sb.AppendFormat(" {0};", methodBody); sb.AppendLine(); sb.AppendLine(" }"); }
public void WriteVisibility(string instance, MethodVisibility visibility) { if ((visibility & MethodVisibility.Assembly) != MethodVisibility.PrivateScope) { Write("{0}.Attributes |= System.CodeDom.MethodVisibility.Assembly", instance); WriteEndStatement(); } if ((visibility & MethodVisibility.Family) != MethodVisibility.PrivateScope) { Write("{0}.Attributes |= System.CodeDom.MethodVisibility.Family", instance); WriteEndStatement(); } if ((visibility & MethodVisibility.Private) != MethodVisibility.PrivateScope) { Write("{0}.Attributes |= System.CodeDom.MethodVisibility.Private", instance); WriteEndStatement(); } }
/// <summary> /// hack to set visibility of events - must be last added as it is a comments that hacks it /// </summary> /// <param name="targetMethod"></param> /// <param name="evt"></param> public static void SetMethodVisibility(CodeMemberMethod targetMethod, EventType evt) { targetMethod.Attributes = MemberAttributes.Overloaded; MethodVisibility visibility = MethodVisibility.none; string vTag = visibility.ToString( ); switch (evt.visibility) { case "public": visibility = MethodVisibility.@public; targetMethod.Attributes = MemberAttributes.Public; break; case "protected": visibility = MethodVisibility.@protected; break; case "internal": visibility = MethodVisibility.@internal; break; case "none": visibility = MethodVisibility.none; break; case "private": visibility = MethodVisibility.@private; targetMethod.Attributes = MemberAttributes.Private; break; default: visibility = MethodVisibility.@public; break; } //targetMethod.Comments.Add(new CodeCommentStatement(CoderBase.LineReplacementFlag + visibility )); if (visibility != MethodVisibility.@public && visibility != MethodVisibility.@private && visibility != MethodVisibility.none) { targetMethod.CustomAttributes.Add( new CodeAttributeDeclaration(CoderBase.MethodVisibilityHackReplacementFlag + visibility)); } }
private static MethodVisibility DetermineVisibility(IPropertyDeclaration propertyDeclaration) { if (propertyDeclaration.SetMethod == null) { return(propertyDeclaration.GetMethod.Resolve().Visibility); } if (propertyDeclaration.GetMethod == null) { return(propertyDeclaration.SetMethod.Resolve().Visibility); } MethodVisibility getMethodVisibility = propertyDeclaration.GetMethod.Resolve().Visibility; MethodVisibility setMethodVisibility = propertyDeclaration.SetMethod.Resolve().Visibility; if (getMethodVisibility < setMethodVisibility) { return(setMethodVisibility); } return(getMethodVisibility); }
public static MethodVisibility GetVisibility(IPropertyReference value) { IMethodDeclaration getMethod = GetGetMethod(value); IMethodDeclaration setMethod = GetSetMethod(value); MethodVisibility @public = MethodVisibility.Public; if ((setMethod != null) && (getMethod != null)) { if (getMethod.Visibility == setMethod.Visibility) { @public = getMethod.Visibility; } return(@public); } if (setMethod != null) { return(setMethod.Visibility); } if (getMethod != null) { @public = getMethod.Visibility; } return(@public); }
private static MethodVisibility __GetPropertyVisibility(IPropertyDeclaration propDecl, out IMethodDeclaration getter, out IMethodDeclaration setter) { IMethodReference getref = propDecl.GetMethod; IMethodReference setref = propDecl.SetMethod; if (getref == null) { getter = null; if (setref == null) { setter = null; return(MethodVisibility.Private); } else { setter = setref.Resolve(); return(setter.Visibility); } } else { getter = getref.Resolve(); if (setref == null) { setter = null; return(getter.Visibility); } else { setter = setref.Resolve(); MethodVisibility max = (MethodVisibility)System.Math.Max((int)getter.Visibility, (int)setter.Visibility); MethodVisibility min = (MethodVisibility)System.Math.Min((int)getter.Visibility, (int)setter.Visibility); return(min == MethodVisibility.Assembly && max == MethodVisibility.Family?MethodVisibility.FamilyOrAssembly:max); } } }
private void BuildTypeTreeNode(ITypeDeclaration typeDeclaration, TreeNode parentNode) { SortedList <String, TreeNode> list = new SortedList <string, TreeNode>(); // Types foreach (ITypeDeclaration nestedTypeDeclaration in typeDeclaration.Types) { StringBuilder builder = new StringBuilder(); MakeTypeDeclarationName(nestedTypeDeclaration, builder); TreeNode typeNode = new TreeNode(builder.ToString()); typeNode.Tag = nestedTypeDeclaration; if (nestedTypeDeclaration.IsEnum) { typeNode.ImageIndex = EnumImageIndex; typeNode.SelectedImageIndex = EnumImageIndex; } else if (nestedTypeDeclaration.IsInterface) { typeNode.ImageIndex = InterfaceImageIndex; typeNode.SelectedImageIndex = InterfaceImageIndex; } else { typeNode.ImageIndex = ClassImageIndex; typeNode.SelectedImageIndex = ClassImageIndex; } BuildTypeTreeNode(nestedTypeDeclaration, typeNode); list.Add(builder.ToString(), typeNode); } parentNode.Nodes.AddRange(list.Values.ToArray()); list.Clear(); // Methods foreach (IMethodDeclaration methodDeclaration in typeDeclaration.Constructors) { TreeNode methodNode = GenerateMethodNode(methodDeclaration); if (!list.ContainsKey(methodNode.Text)) { list.Add(methodNode.Text, methodNode); } else { list.Add(methodNode.Text + Guid.NewGuid(), methodNode); } } parentNode.Nodes.AddRange(list.Values.ToArray()); list.Clear(); // Methods foreach (IMethodDeclaration methodDeclaration in typeDeclaration.Methods) { TreeNode methodNode = GenerateMethodNode(methodDeclaration); if (!list.ContainsKey(methodNode.Text)) { list.Add(methodNode.Text, methodNode); } else { list.Add(methodNode.Text + Guid.NewGuid(), methodNode); } } parentNode.Nodes.AddRange(list.Values.ToArray()); list.Clear(); // Properties foreach (IPropertyDeclaration propertyDeclaration in typeDeclaration.Properties) { TreeNode propertyNode = new TreeNode(propertyDeclaration.Name); propertyNode.Tag = propertyDeclaration; MethodVisibility propertyVisibility = DetermineVisibility(propertyDeclaration); if (propertyVisibility == MethodVisibility.Assembly) { propertyNode.ImageIndex = ProtectedPropertyImageIndex; propertyNode.SelectedImageIndex = ProtectedPropertyImageIndex; } else if ((propertyVisibility == MethodVisibility.Family) || (propertyVisibility == MethodVisibility.FamilyOrAssembly)) { propertyNode.ImageIndex = InternalPropertyImageIndex; propertyNode.SelectedImageIndex = InternalPropertyImageIndex; } else if (propertyVisibility == MethodVisibility.Private) { propertyNode.ImageIndex = PrivatePropertyImageIndex; propertyNode.SelectedImageIndex = PrivatePropertyImageIndex; } else { propertyNode.ImageIndex = PublicPropertyImageIndex; propertyNode.SelectedImageIndex = PublicPropertyImageIndex; } list.Add(propertyDeclaration.Name, propertyNode); if (propertyDeclaration.GetMethod != null) { propertyNode.Nodes.Add(GenerateMethodNode(propertyDeclaration.GetMethod.Resolve())); } if (propertyDeclaration.SetMethod != null) { propertyNode.Nodes.Add(GenerateMethodNode(propertyDeclaration.SetMethod.Resolve())); } } parentNode.Nodes.AddRange(list.Values.ToArray()); list.Clear(); // Non-Constant fields foreach (IFieldDeclaration fieldDeclaration in typeDeclaration.Fields) { if (!fieldDeclaration.IsConst) { TreeNode fieldNode = new TreeNode(fieldDeclaration.Name); fieldNode.Tag = fieldDeclaration; if (fieldDeclaration.Visibility == FieldVisibility.Public) { fieldNode.ImageIndex = PublicFieldIndex; fieldNode.SelectedImageIndex = PublicFieldIndex; } else if (fieldDeclaration.Visibility == FieldVisibility.Private) { fieldNode.ImageIndex = PrivateFieldIndex; fieldNode.SelectedImageIndex = PrivateFieldIndex; } else if (fieldDeclaration.Visibility == FieldVisibility.Assembly) { fieldNode.ImageIndex = InternalFieldIndex; fieldNode.SelectedImageIndex = InternalFieldIndex; } else { fieldNode.ImageIndex = ProtectedFieldIndex; fieldNode.SelectedImageIndex = ProtectedFieldIndex; } list.Add(fieldDeclaration.Name, fieldNode); } } parentNode.Nodes.AddRange(list.Values.ToArray()); list.Clear(); // Events foreach (IEventDeclaration eventDeclaration in typeDeclaration.Events) { TreeNode eventNode = new TreeNode(eventDeclaration.Name); eventNode.Tag = eventDeclaration; eventNode.Nodes.Add(GenerateMethodNode(eventDeclaration.AddMethod.Resolve())); eventNode.Nodes.Add(GenerateMethodNode(eventDeclaration.RemoveMethod.Resolve())); list.Add(eventDeclaration.Name, eventNode); } parentNode.Nodes.AddRange(list.Values.ToArray()); list.Clear(); // Constant fields foreach (IFieldDeclaration fieldDeclaration in typeDeclaration.Fields) { if (fieldDeclaration.IsConst) { TreeNode fieldNode = new TreeNode(fieldDeclaration.Name); fieldNode.Tag = fieldDeclaration; if (fieldDeclaration.Visibility == FieldVisibility.Public) { fieldNode.ImageIndex = PublicConstIndex; fieldNode.SelectedImageIndex = PublicConstIndex; } else if (fieldDeclaration.Visibility == FieldVisibility.Private) { fieldNode.ImageIndex = PrivateConstIndex; fieldNode.SelectedImageIndex = PrivateConstIndex; } else if (fieldDeclaration.Visibility == FieldVisibility.Assembly) { fieldNode.ImageIndex = InternalConstIndex; fieldNode.SelectedImageIndex = InternalConstIndex; } else { fieldNode.ImageIndex = ProtectedConstIndex; fieldNode.SelectedImageIndex = ProtectedConstIndex; } list.Add(fieldDeclaration.Name, fieldNode); } } parentNode.Nodes.AddRange(list.Values.ToArray()); }
//=========================================================== // 宣言 //=========================================================== public virtual void WritePropertyDeclaration(IPropertyDeclaration propDecl) { // アクセス修飾子情報 IMethodDeclaration getter; IMethodDeclaration setter; MethodVisibility vis = __GetPropertyVisibility(propDecl, out getter, out setter); this.__WriteVisibilitySpecifier(vis); #warning generic property // 修飾子 if (getter != null && getter.Static || setter != null && setter.Static) { this.WriteKeyword("static"); this.Write(" "); } this.WriteKeyword("property"); this.Write(" "); this.WriteType(propDecl.PropertyType, null, null, null, false); this.Write(" "); this.WriteDeclaration(propDecl.Name); IParameterDeclarationCollection parameters = propDecl.Parameters; if (parameters != null) { this.WritePropertyIndices(parameters); } // // 内容の書込 // //--------------------------------------------------- // inline == true → 宣言だけを書く場合 // inline == false → アクセサのロジックも書く場合 bool inline = !(getter != null && getter.Body != null || setter != null && setter.Body != null); this.Write("{"); if (inline) { this.Write(" "); } else { this.WriteIndent(); this.WriteLine(); } //----------------------------------------- this.PushScope(); //----------------------------------------- if (getter != null) { if (getter.Visibility != vis) { this.__WriteVisibilitySpecifier(getter.Visibility, inline); } this.__WritePropertyAccessorSignature("get", getter, inline); this.__WriteMethodBody(getter.Body as IBlockStatement); //,true if (inline) { this.Write(" "); } else { this.WriteLine(); } } //----------------------------------------- this.PopScope(); this.PushScope(); //----------------------------------------- if (setter != null) { if (getter != null && setter.Visibility != getter.Visibility) { this.__WriteVisibilitySpecifier(setter.Visibility, inline); } this.__WritePropertyAccessorSignature("set", setter, inline); this.__WriteMethodBody(setter.Body as IBlockStatement); //,true if (inline) { this.Write(" "); } else { this.WriteLine(); } } //----------------------------------------- this.PopScope(); //----------------------------------------- if (!inline) { this.WriteOutdent(); } this.Write("}"); }
public void WriteMethodVisibility(MethodVisibility visibility, IFormatter formatter) { switch (visibility) { case MethodVisibility.Public: formatter.WriteKeyword("public"); break; case MethodVisibility.Private: formatter.WriteKeyword("strict private"); break; case MethodVisibility.PrivateScope: formatter.WriteKeyword("private"); formatter.Write(" "); formatter.WriteComment("{scope}"); break; case MethodVisibility.Family: formatter.WriteKeyword("strict protected"); break; case MethodVisibility.Assembly: formatter.WriteKeyword("private"); break; case MethodVisibility.FamilyOrAssembly: formatter.WriteKeyword("protected"); break; case MethodVisibility.FamilyAndAssembly: formatter.WriteKeyword("protected"); formatter.Write(" "); formatter.WriteComment("{internal}"); break; default: throw new NotSupportedException(); } formatter.Write(" "); }
public static void SetMethodVisibility(CodeMemberMethod targetMethod, MethodVisibility visibility) { targetMethod.Attributes = MemberAttributes.Overloaded; targetMethod.Comments.Add(new CodeCommentStatement(CoderBase.LineReplacementFlag + visibility)); }