C# MethodDefinition.IsCompilerGenerated方法代码示例

		// All we care about are the method properties and the name so we can get
		// by with just visiting MethodDefinition. 
		public void VisitMethod(MethodDefinition method)
		{
			// If the method is not private,
			if ((method.Attributes & MethodAttributes.MemberAccessMask) != MethodAttributes.Private)
			{
				// not a ctor, not virtual (it'll be virtual if it's an explicit interface
				// member implementation), and not a property or event,
				if (!method.IsConstructor && !method.IsVirtual && method.SemanticsAttributes == 0)
				{
					// then it's a candidate for our rule so we'll go ahead and
					// do some logging. Note that DebugLine is compiled out in
					// release builds.
					Log.DebugLine(this, "-----------------------------------"); 
					Log.DebugLine(this, "{0}", method);				
			
					// If the name starts with Do and isn't compiler generated,
					if (method.Name.StartsWith("Do") && !method.IsCompilerGenerated())
					{
						// then we have a failure. For rules which fail within a
						// method, offset should be the first offset to the instruction
						// which triggered the violation. Details can be used to
						// communicate additional information to the user about the
						// cause of the violation.
						int offset = 0;
						string details = string.Empty;
						Log.DebugLine(this, "doesn't start with Do");
						
						// Note that there are also AssemblyFailed and TypeFailed methods.
						Reporter.MethodFailed(method, CheckID, offset, details);
					}
				}
			}
		}

		public static MethodDefinition GetOriginalCodeLocation(MethodDefinition method)
		{
			if (method.IsCompilerGenerated()) {
				return FindMethodUsageInType(method.DeclaringType, method) ?? method;
			}

			var typeUsage = GetOriginalCodeLocation(method.DeclaringType);

			return typeUsage ?? method;
		}

        public static string FormatAccessor(string name, MethodDefinition accessor, bool needsAttributes)
        {
            if (accessor == null || String.IsNullOrEmpty (name))
                return String.Empty;

            var sb = new StringBuilder ();
            Utils.Indent++;
            try {
                sb.AppendLine ();
                if (accessor.HasCustomAttributes)
                    sb.Append (accessor.CustomAttributes.Format ());
                if (needsAttributes) {
                    sb.AppendIndent (FormatAttributes (accessor));
                    sb.Append (' ');
                } else
                    sb.AppendIndent ();

                sb.Append (name);
                bool needNewline = false;
                if (accessor.IsAbstract || accessor.DeclaringType.IsInterface || (needNewline = accessor.IsCompilerGenerated ())) {
                    sb.Append (";");
                } else
                    sb.Append (" { throw new NotImplementedException (); }");
            } finally {
                Utils.Indent--;
            }

            return sb.ToString ();
        }

        /// <summary>
        /// Add the given method to its declaring class.
        /// </summary>
        protected virtual void SetAccessFlags(DexLib.MethodDefinition dmethod, MethodDefinition method)
        {
            // subclass accesses have already been fixed on an actual use basis.
            if (method.IsPrivate)
                dmethod.IsPrivate = true;
            else if (method.IsFamily || method.IsFamilyOrAssembly) 
                dmethod.IsProtected = true;
            else
                dmethod.IsPublic = true;

            if (method.DeclaringType.IsInterface)
            {
                dmethod.IsAbstract = true;
                //dmethod.
            }
            else
            {
                if (method.IsConstructor)
                {
                    dmethod.IsConstructor = true;
                    dmethod.IsStatic = method.IsStatic;
                    if (method.IsStatic)
                    {
                        // reset access modifiers for static constructors.
                        dmethod.IsPrivate = false;
                        dmethod.IsProtected = false;
                    }
                }
                else if (method.IsAbstract) dmethod.IsAbstract = true;
                else if (method.IsVirtual) dmethod.IsVirtual = true;
                else if (method.IsStatic) dmethod.IsStatic = true;
                else dmethod.IsFinal = true;
                //if (method.IsInitOnly) dmethod.IsFinal = true;
            }

            if (method.IsCompilerGenerated())
                dmethod.IsSynthetic = true;
        }