public override IExpression Rewrite(ICreateDelegateInstance createDelegateInstance) { IMethodDefinition delegateMethodDefinition = createDelegateInstance.MethodToCallViaDelegate.ResolvedMethod; if (this.closures != null && this.closures.Find(delegateMethodDefinition.ContainingTypeDefinition.InternedKey) != null) { Contract.Assume(!(delegateMethodDefinition is Dummy)); return(this.ConvertToAnonymousDelegate(delegateMethodDefinition, createDelegateInstance.Type)); } if (delegateMethodDefinition.Visibility == TypeMemberVisibility.Private && AttributeHelper.Contains(delegateMethodDefinition.Attributes, this.host.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute)) { //The method that is enclosed in the delegate is private and it has been generated by a compiler. //We assume that means that this delegate is an anonymous delegate and we'll rewrite the expression as such. //The anonymous delegate will not have captured anything other than the this parameter, otherwise it would be an instance method on a closure class. if (this.containingMethod.IsGeneric) { var genInst = delegateMethodDefinition as IGenericMethodInstance; if (genInst == null) { return(createDelegateInstance); //Anonymous delegates have to be generic in this case. } if (this.GenericArgumentsDoNotMatchGenericParameters(genInst.GenericArguments)) { return(createDelegateInstance); } } this.AddToPrivateHelperMethodsToRemove(MemberHelper.UninstantiateAndUnspecialize(delegateMethodDefinition)); Contract.Assume(!(delegateMethodDefinition is Dummy)); return(this.ConvertToAnonymousDelegate(delegateMethodDefinition, createDelegateInstance.Type)); } return(createDelegateInstance); }
/// <summary> /// See if a type reference refers to a type definition that is compiler generated. /// </summary> /// <param name="typeReference"></param> /// <returns></returns> internal static bool IsCompilerGenerated(ITypeReference /*!*/ typeReference) { if (AttributeHelper.Contains(typeReference.ResolvedType.Attributes, typeReference.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute)) { return(true); } IGenericTypeInstanceReference genericTypeInstanceReference = typeReference as IGenericTypeInstanceReference; if (genericTypeInstanceReference != null && IsCompilerGenerated(genericTypeInstanceReference.GenericType)) { return(true); } ISpecializedNestedTypeReference specializedNestedType = typeReference as ISpecializedNestedTypeReference; if (specializedNestedType != null && IsCompilerGenerated(specializedNestedType.UnspecializedVersion)) { return(true); } ISpecializedNestedTypeDefinition specializedNestedTypeDefinition = typeReference as ISpecializedNestedTypeDefinition; if (specializedNestedTypeDefinition != null && IsCompilerGenerated(specializedNestedTypeDefinition.UnspecializedVersion)) { return(true); } INestedTypeReference nestedTypeReference = UnspecializedMethods.AsUnspecializedNestedTypeReference(typeReference); if (nestedTypeReference != null) { return(IsCompilerGenerated(nestedTypeReference.ContainingType)); } return(false); }
public override void TraverseChildren(ITypeDefinition typeDefinition) { if (AttributeHelper.Contains(typeDefinition.Attributes, this.host.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute)) { return; } if (ContractHelper.IsContractClass(this.host, typeDefinition)) { return; } if (typeDefinition.IsEnum) { return; } Console.WriteLine(TypeHelper.GetTypeName(typeDefinition, NameFormattingOptions.TypeParameters)); this.indentLevel++; var unit = TypeHelper.GetDefiningUnit(typeDefinition); if (unit != null) { var ce = this.host.GetContractExtractor(unit.UnitIdentity); if (ce != null) { PrintTypeContract(ce.GetTypeContractFor(typeDefinition)); } } base.TraverseChildren(typeDefinition); this.indentLevel--; }
public override void TraverseChildren(IMethodDefinition methodDefinition) { if (AttributeHelper.Contains(methodDefinition.Attributes, this.host.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute)) { return; } if (ContractHelper.IsInvariantMethod(this.host, methodDefinition)) { return; } if (IsGetter(methodDefinition) || IsSetter(methodDefinition)) { return; } IMethodContract methodContract; if (this.showInherited) { methodContract = ContractHelper.GetMethodContractForIncludingInheritedContracts(this.host, methodDefinition); } else { methodContract = ContractHelper.GetMethodContractFor(this.host, methodDefinition); } Indent(); var methodSig = MemberHelper.GetMethodSignature(methodDefinition, NameFormattingOptions.Signature | NameFormattingOptions.ParameterName | NameFormattingOptions.ParameterModifiers); Console.WriteLine(methodSig); this.indentLevel++; PrintMethodContract(methodContract); this.indentLevel--; }
public override void TraverseChildren(INestedTypeDefinition nestedTypeDefinition) { if (!this.printCompilerGeneratedMembers && AttributeHelper.Contains(nestedTypeDefinition.Attributes, nestedTypeDefinition.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute)) { return; } PrintTypeDefinition(nestedTypeDefinition as ITypeDefinition); }
public override void RewriteChildren(MethodDefinition method) { if (method.Attributes != null && AttributeHelper.Contains(method.Attributes, this.host.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute)) { return; } if (TypeHelper.IsCompilerGenerated(method.ContainingTypeDefinition)) { return; } //if (Microsoft.Cci.MutableContracts.ContractHelper.IsContractClass(this.host, method.ContainingTypeDefinition)) return; // if a method in a contract class was considered reachable, then keep its method body #region Add attribute with its hash MethodHashAttribute mhAttr; List <IMetadataExpression> args; Contract.Assume(this.copier.OriginalFor.ContainsKey(method)); var originalMethod = (IMethodDefinition)this.copier.OriginalFor[method]; if (this.methodHashAttributes.TryGetValue(originalMethod, out mhAttr)) { args = new List <IMetadataExpression> { new MetadataConstant() { Type = this.systemString, Value = mhAttr.Arg1, }, new MetadataConstant() { Type = this.systemInt, Value = mhAttr.Arg2, }, }; } else { // add attribute that says to *not* analyze this method: it is here only because it was discovered as being called somewhere args = new List <IMetadataExpression> { new MetadataConstant() { Type = this.systemString, Value = null, }, new MetadataConstant() { Type = this.systemInt, Value = ((int)MethodHashAttributeFlags.ForDependenceMethod), }, }; } var attr = new CustomAttribute() { Constructor = this.methodHashAttributeCtor, Arguments = args, }; if (method.Attributes == null) { method.Attributes = new List <ICustomAttribute>(1); } method.Attributes.Add(attr); #endregion base.RewriteChildren(method); }
public override void RewriteChildren(Assignment assignment) { base.RewriteChildren(assignment); var anonDel = assignment.Source as IAnonymousDelegate; if (anonDel != null) { var targetField = assignment.Target.Definition as IFieldReference; if (targetField != null && targetField.ResolvedField.IsStatic && (AttributeHelper.Contains(targetField.ResolvedField.Attributes, this.host.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute) || AttributeHelper.Contains(targetField.ResolvedField.ContainingTypeDefinition.Attributes, this.host.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute))) { var specializedTargetField = targetField as ISpecializedFieldReference; if (this.delegatesCachedInFields == null) { this.delegatesCachedInFields = new Hashtable <IAnonymousDelegate>(); } this.delegatesCachedInFields[targetField.InternedKey] = anonDel; if (this.sourceMethodBody.privateHelperFieldsToRemove == null) { this.sourceMethodBody.privateHelperFieldsToRemove = new List <IFieldDefinition>(); } if (specializedTargetField != null) { targetField = specializedTargetField.UnspecializedVersion; } this.sourceMethodBody.privateHelperFieldsToRemove.Add(targetField.ResolvedField); } return; } if (this.closures != null && this.closures.Find(assignment.Source.Type.InternedKey) != null) { var targetField = assignment.Target.Definition as IFieldReference; if (targetField != null) { var specializedTargetField = targetField as ISpecializedFieldReference; if (this.sourceMethodBody.privateHelperFieldsToRemove == null) { this.sourceMethodBody.privateHelperFieldsToRemove = new List <IFieldDefinition>(); } if (specializedTargetField != null) { targetField = specializedTargetField.UnspecializedVersion; } this.sourceMethodBody.privateHelperFieldsToRemove.Add(targetField.ResolvedField); } } }
/// <summary> /// Returns true if the given field reference refers to a field that is compiler generated. /// </summary> public static bool IsCompilerGenerated(IFieldReference /*!*/ fieldReference) { var specializedFieldReference = fieldReference as ISpecializedFieldReference; if (specializedFieldReference != null) { return(IsCompilerGenerated(specializedFieldReference.UnspecializedVersion)); } if (IsCompilerGenerated(fieldReference.ContainingType)) { return(true); } var field = fieldReference.ResolvedField; //This is unfortunate, but in the case of a (specialized) field reference where the containing type is a generic type instance //the unspecialized field is not a definition even if the generic type template is defined in the same assembly. Resolving seems to be the only way to tell. return(AttributeHelper.Contains(field.Attributes, field.ContainingType.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute)); }
/// <summary> /// See if a method definition is compiler generated, or is inside a compiler generated type. /// </summary> /// <param name="methodDefinition"></param> /// <returns></returns> internal static bool IsCompilerGenerated(IMethodDefinition /*!*/ methodDefinition) { if (AttributeHelper.Contains(methodDefinition.Attributes, methodDefinition.ContainingType.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute)) { return(true); } IGenericMethodInstance genericMethodInstance = methodDefinition as IGenericMethodInstance; if (genericMethodInstance != null) { return(IsCompilerGenerated(genericMethodInstance.GenericMethod.ResolvedMethod)); } if (methodDefinition.ContainingType == null) { return(false); } return(IsCompilerGenerated(methodDefinition.ContainingType)); }
private static IMethodBody /*?*/ FirstStatementIsIteratorCreation(IMetadataHost host, ISourceMethodBody possibleIterator, INameTable nameTable, IStatement statement) { ICreateObjectInstance createObjectInstance = GetICreateObjectInstance(statement); if (createObjectInstance == null) { // If the first statement in the method body is not the creation of iterator closure, return a dummy. // Possible corner case not handled: a local is used to hold the constant value for the initial state of the closure. return(null); } ITypeReference closureType /*?*/ = createObjectInstance.MethodToCall.ContainingType; ITypeReference unspecializedClosureType = ContractHelper.Unspecialized(closureType); if (!AttributeHelper.Contains(unspecializedClosureType.Attributes, host.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute)) { return(null); } INestedTypeReference closureTypeAsNestedTypeReference = unspecializedClosureType as INestedTypeReference; if (closureTypeAsNestedTypeReference == null) { return(null); } ITypeReference unspecializedClosureContainingType = ContractHelper.Unspecialized(closureTypeAsNestedTypeReference.ContainingType); if (closureType != null && TypeHelper.TypesAreEquivalent(possibleIterator.MethodDefinition.ContainingTypeDefinition, unspecializedClosureContainingType)) { IName MoveNextName = nameTable.GetNameFor("MoveNext"); foreach (ITypeDefinitionMember member in closureType.ResolvedType.GetMembersNamed(MoveNextName, false)) { IMethodDefinition moveNext = member as IMethodDefinition; if (moveNext != null) { ISpecializedMethodDefinition moveNextGeneric = moveNext as ISpecializedMethodDefinition; if (moveNextGeneric != null) { moveNext = moveNextGeneric.UnspecializedVersion.ResolvedMethod; } return(moveNext.Body); } } } return(null); }
public override void TraverseChildren(ICreateDelegateInstance createDelegateInstance) { base.TraverseChildren(createDelegateInstance); var delegateMethodDefinition = createDelegateInstance.MethodToCallViaDelegate.ResolvedMethod; var containingTypeDefinition = delegateMethodDefinition.ContainingTypeDefinition; if (TypeHelper.IsCompilerGenerated(containingTypeDefinition)) { if (!containingTypeDefinition.IsValueType) //If it is a value type, is is probably the state class of an async method. { if (this.closures == null) { this.closures = new Hashtable <object>(); } this.closures.Add(containingTypeDefinition.InternedKey, containingTypeDefinition); this.AddOuterClosures(containingTypeDefinition); this.sawAnonymousDelegate = true; } } else { this.sawAnonymousDelegate |= AttributeHelper.Contains(delegateMethodDefinition.Attributes, this.host.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute); } }
internal int Run() { SecurityKeepOptions securityKeepOptions = options.onlySecurityTransparent ? SecurityKeepOptions.OnlyNonCritical : SecurityKeepOptions.All; if (options.doBreak) { System.Diagnostics.Debugger.Launch(); } string assemblyName = null; if (options.GeneralArguments.Count == 1) { assemblyName = options.GeneralArguments[0]; } if (assemblyName == null) { errorLogger("Must specify an input file."); return(1); } using (var host = new AsmMetaHostEnvironment(options.libPaths.ToArray(), options.searchGAC)) { foreach (var p in options.resolvedPaths) { host.AddResolvedPath(p); } IAssembly /*?*/ assembly = host.LoadUnitFrom(assemblyName) as IAssembly; if (assembly == null || assembly is Dummy) { errorLogger(assemblyName + " is not a PE file containing a CLR assembly, or an error occurred when loading it."); return(1); } var rewrittenAttribute = CreateTypeReference(host, assembly, "System.Diagnostics.Contracts.RuntimeContractsAttribute"); if (AttributeHelper.Contains(assembly.Attributes, rewrittenAttribute)) { errorLogger(assemblyName + " is already rewritten, cannot generate a reference assembly from it."); return(1); } if (options.backwardCompatibility) { // redundant because RemoveMethodBodies.ctor also does this when the flag is set options.whatToEmit = KeepOptions.ExtVis; options.emitAttributes = false; } PdbReader /*?*/ pdbReader = null; if (options.includeSourceTextInContract) { // No point getting the PDB file unless we want to use it for source text string pdbFile = Path.ChangeExtension(assembly.Location, "pdb"); if (File.Exists(pdbFile)) { using (var pdbStream = File.OpenRead(pdbFile)) { pdbReader = new PdbReader(pdbStream, host); } } else { errorLogger("Could not load the PDB file for the assembly '" + assembly.Name.Value + "' . Source text will not be preserved in the reference assembly. Proceeding anyway."); } } using (pdbReader) { // We might be working on the assembly that defines the contract class and/or the type System.Void. // (Or any other platform type!) // But the host.PlatformType object has not been duplicated, so its properties will continue to be references to the immutable ones. // This is OK, except if the assembly is being renamed. this.compilerGeneratedAttributeType = host.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute; this.contractClassType = host.PlatformType.SystemDiagnosticsContractsContract; this.systemAttributeType = host.PlatformType.SystemAttribute; this.systemBooleanType = host.PlatformType.SystemBoolean; this.systemStringType = host.PlatformType.SystemString; this.systemObjectType = host.PlatformType.SystemObject; this.systemVoidType = host.PlatformType.SystemVoid; //new FindPlatformTypes(this).Traverse(assembly); //update the above fields if any of those types are defined in mutable Assembly mutable = new MetadataDeepCopier(host).Copy(assembly); #region Rename the assembly in a separate pass because things done in later passes depend on interned keys that are computed based (in part) on the assembly identity if (options.rename) { if (options.output != null) { mutable.Name = host.NameTable.GetNameFor(Path.GetFileNameWithoutExtension(options.output)); } else { mutable.Name = host.NameTable.GetNameFor(assembly.Name.Value + ".Contracts"); } mutable.ModuleName = mutable.Name; mutable.Kind = ModuleKind.DynamicallyLinkedLibrary; mutable = (Assembly)RenameAssembly.ReparentAssemblyIdentity(host, assembly.AssemblyIdentity, mutable.AssemblyIdentity, mutable); } #endregion Rename the assembly in a separate pass because things done in later passes depend on interned keys that are computed based (in part) on the assembly identity if (!options.renameOnly) { if (options.contracts) { if (options.rename) { // We might be working on the assembly that defines the contract class and/or the type System.Void. // (Or any other platform type!) // But the host.PlatformType object has not been duplicated, so its properties will continue to be references to the immutable ones. // This is OK, except if the assembly is being renamed. var systemNamespace = GetFirstMatchingNamespace(host, mutable.UnitNamespaceRoot, "System"); if (systemNamespace != null) { var typeDefinition = GetFirstMatchingTypeDefinition(host, systemNamespace, "Attribute"); if (typeDefinition != null) { this.systemAttributeType = typeDefinition; } typeDefinition = GetFirstMatchingTypeDefinition(host, systemNamespace, "Boolean"); if (typeDefinition != null) { this.systemBooleanType = typeDefinition; } typeDefinition = GetFirstMatchingTypeDefinition(host, systemNamespace, "Object"); if (typeDefinition != null) { this.systemObjectType = typeDefinition; } typeDefinition = GetFirstMatchingTypeDefinition(host, systemNamespace, "String"); if (typeDefinition != null) { this.systemStringType = typeDefinition; } typeDefinition = GetFirstMatchingTypeDefinition(host, systemNamespace, "Void"); if (typeDefinition != null) { this.systemVoidType = typeDefinition; } var systemRuntimeNamespace = GetFirstMatchingNamespace(host, systemNamespace, "Runtime"); if (systemRuntimeNamespace != null) { var systemRuntimeCompilerServicesNamespace = GetFirstMatchingNamespace(host, systemRuntimeNamespace, "CompilerServices"); if (systemRuntimeCompilerServicesNamespace != null) { typeDefinition = GetFirstMatchingTypeDefinition(host, systemRuntimeCompilerServicesNamespace, "CompilerGeneratedAttribute"); if (typeDefinition != null) { this.compilerGeneratedAttributeType = typeDefinition; } } } var systemDiagnosticsNamespace = GetFirstMatchingNamespace(host, systemNamespace, "Diagnostics"); if (systemDiagnosticsNamespace != null) { var systemDiagnosticsContractsNamespace = GetFirstMatchingNamespace(host, systemDiagnosticsNamespace, "Contracts"); if (systemDiagnosticsContractsNamespace != null) { typeDefinition = GetFirstMatchingTypeDefinition(host, systemDiagnosticsContractsNamespace, "Contract"); if (typeDefinition != null) { this.contractClassType = typeDefinition; } } } } } mutable = AsmMetaRewriter.RewriteModule(host, pdbReader, mutable, contractClassType, compilerGeneratedAttributeType, systemAttributeType, systemBooleanType, systemObjectType, systemStringType, systemVoidType ) as Assembly; } #region Delete things that are not to be kept if (options.backwardCompatibility || options.whatToEmit != KeepOptions.All || !options.emitAttributes || (options.attrs != null && 0 < options.attrs.Count)) { DeleteThings thinner = new DeleteThings(host, options.whatToEmit, securityKeepOptions, options.emitAttributes, options.attrs.ToArray(), options.backwardCompatibility); if (securityKeepOptions == SecurityKeepOptions.OnlyNonCritical && host.platformType.SystemSecuritySecurityCriticalAttribute.ResolvedType is Dummy) { errorLogger("You asked to remove security critical methods, but the version of mscorlib doesn't support the SecurityCriticalAttribute."); return(1); } thinner.RewriteChildren(mutable); #region Fix up dangling references to things that were deleted FixUpReferences patcher = new FixUpReferences(host, thinner.WhackedMethods, thinner.WhackedTypes); patcher.RewriteChildren(mutable); #endregion Fix up dangling references to things that were deleted } #endregion Delete things that are not to be kept #region Output is always a dll, so mark the assembly as that mutable.EntryPoint = Dummy.MethodReference; mutable.Kind = ModuleKind.DynamicallyLinkedLibrary; #endregion Output is always a dll, so mark the assembly as that } assembly = mutable; string outputPath; if (options.output != null) // user specified, they'd better make sure it doesn't conflict with anything { outputPath = options.output; } else if (options.rename) // A.dll ==> A.Contracts.dll (Always! Even if the input is an exe!) { outputPath = assembly.Name.Value + ".dll"; } else // A.dll ==> A.dll.meta { outputPath = assembly.Name.Value + Path.GetExtension(assemblyName) + ".meta"; } // NB: Do *not* pass a pdbWriter to WritePeToStream. No need to create a PDB file and if // it is provided, then it might find things (like constants in a scope) that don't get // visited and so don't have any type references modified as they should be. using (var outputFile = File.Create(outputPath)) { if (pdbReader != null && options.writePDB) { using (var pdbWriter = new PdbWriter(Path.ChangeExtension(outputPath, "pdb"), pdbReader)) { // Need to not pass in a local scope provider until such time as we have one that will use the mutator // to remap things (like the type of a scope constant) from the original assembly to the mutated one. PeWriter.WritePeToStream(assembly, host, outputFile, pdbReader, null /*pdbReader*/, pdbWriter); } } else { PeWriter.WritePeToStream(assembly, host, outputFile); } } } } return(0); // success }
private bool IsContractClass(ITypeDefinition typeDefinition) { Contract.Requires(typeDefinition != null); return(AttributeHelper.Contains(typeDefinition.Attributes, ContractClassForAttribute)); }
private bool IsPure(IMethodDefinition methodDefinition) { Contract.Requires(methodDefinition != null); return(AttributeHelper.Contains(methodDefinition.Attributes, PureAttribute)); }
public override void TraverseChildren(IFieldDefinition fieldDefinition) { if (fieldDefinition.ContainingType.IsEnum && fieldDefinition.IsRuntimeSpecial && fieldDefinition.IsSpecialName) { return; // implicit value field of an enum } if (!this.printCompilerGeneratedMembers && AttributeHelper.Contains(fieldDefinition.Attributes, fieldDefinition.Type.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute)) { return; // eg. a cached anonymous delegate - may have invalid symbols } foreach (var e in fieldDefinition.ContainingTypeDefinition.Events) { if (e.Name == fieldDefinition.Name) { return; // field is probably the implicit delegate backing the event } } // Figure out if this is a special fixed buffer field ICustomAttribute fixedBufferAttr = Utils.FindAttribute(fieldDefinition.Attributes, SpecialAttribute.FixedBuffer); if (fixedBufferAttr == null) { PrintAttributes(fieldDefinition); } if (fieldDefinition.ContainingTypeDefinition.Layout == LayoutKind.Explicit) { PrintPseudoCustomAttribute(fieldDefinition, "System.Runtime.InteropServices.FieldOffset", fieldDefinition.Offset.ToString(), true, null); } PrintToken(VBToken.Indent); if (fieldDefinition.IsCompileTimeConstant && fieldDefinition.ContainingType.IsEnum) { PrintFieldDefinitionEnumValue(fieldDefinition); } else { PrintFieldDefinitionVisibility(fieldDefinition); PrintFieldDefinitionModifiers(fieldDefinition); if (fixedBufferAttr == null) { PrintToken(VBToken.Space); PrintFieldDefinitionName(fieldDefinition); if (fieldDefinition.IsCompileTimeConstant) { sourceEmitterOutput.Write(" = "); PrintFieldDefinitionValue(fieldDefinition); } } else { PrintFieldDefinitionFixedBuffer(fieldDefinition, fixedBufferAttr); } PrintToken(VBToken.Space); PrintToken(VBToken.As); PrintToken(VBToken.Space); PrintFieldDefinitionType(fieldDefinition); //PrintToken(VBToken.Semicolon); } }
private bool IsCompilerGenerated(IMethodDefinition methodDefinition) { return(AttributeHelper.Contains(methodDefinition.Attributes, _host.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute)); }
// Does NOT include methods marked with SecuritySafeCriticalAttribute. private bool IsSecurityCritical(ITypeDefinitionMember member) { return(AttributeHelper.Contains(member.Attributes, this.asmMetaHostEnvironment.platformType.SystemSecuritySecurityCriticalAttribute)); }
public override void TraverseChildren(IMethodDefinition methodDefinition) { if (!this.printCompilerGeneratedMembers) { if (methodDefinition.IsConstructor && methodDefinition.ParameterCount == 0 && AttributeHelper.Contains(methodDefinition.Attributes, methodDefinition.Type.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute)) { return; } // Skip if this is a method generated for use by a property or event foreach (var p in methodDefinition.ContainingTypeDefinition.Properties) { if ((p.Getter != null && p.Getter.ResolvedMethod == methodDefinition) || (p.Setter != null && p.Setter.ResolvedMethod == methodDefinition)) { return; } } foreach (var e in methodDefinition.ContainingTypeDefinition.Events) { if ((e.Adder != null && e.Adder.ResolvedMethod == methodDefinition) || (e.Remover != null && e.Remover.ResolvedMethod == methodDefinition)) { return; } } if (AttributeHelper.Contains(methodDefinition.Attributes, methodDefinition.Type.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute)) { return; // eg. an iterator helper - may have invalid identifier name } } // Cctors should probably be outputted in some cases if (methodDefinition.IsStaticConstructor) { return; } foreach (var ma in SortAttributes(methodDefinition.Attributes)) { if (Utils.GetAttributeType(ma) != SpecialAttribute.Extension) { PrintAttribute(methodDefinition, ma, true, null); } } foreach (var ra in SortAttributes(methodDefinition.ReturnValueAttributes)) { PrintAttribute(methodDefinition, ra, true, "return"); } PrintToken(CSharpToken.Indent); PrintMethodDefinitionVisibility(methodDefinition); PrintMethodDefinitionModifiers(methodDefinition); bool conversion = IsConversionOperator(methodDefinition); if (!conversion) { PrintMethodDefinitionReturnType(methodDefinition); if (!methodDefinition.IsConstructor && !IsDestructor(methodDefinition)) { PrintToken(CSharpToken.Space); } } PrintMethodDefinitionName(methodDefinition); if (conversion) { PrintMethodDefinitionReturnType(methodDefinition); } if (methodDefinition.IsGeneric) { Traverse(methodDefinition.GenericParameters); } Traverse(methodDefinition.Parameters); if (methodDefinition.IsGeneric) { PrintConstraints(methodDefinition.GenericParameters); } if (!methodDefinition.IsAbstract && !methodDefinition.IsExternal) { Traverse(methodDefinition.Body); } else { PrintToken(CSharpToken.Semicolon); } }