private void WriteMethodName(IMethodDefinition method)
{
if (method.IsConstructor || method.IsStaticConstructor)
{
INamedEntity named = method.ContainingTypeDefinition.UnWrap() as INamedEntity;
if (named != null)
{
WriteIdentifier(named.Name.Value);
return;
}
}
if (method.IsExplicitInterfaceMethod())
{
IMethodImplementation methodImplementation = method.GetMethodImplementation();
object nullableAttributeArgument = methodImplementation.GetExplicitInterfaceMethodNullableAttributeArgument(_metadataReaderCache);
if (nullableAttributeArgument != null)
{
WriteTypeName(methodImplementation.ImplementedMethod.ContainingType, noSpace: true, nullableAttributeArgument: nullableAttributeArgument);
WriteSymbol(".");
WriteIdentifier(methodImplementation.ImplementedMethod.Name);
return;
}
}
WriteIdentifier(GetNormalizedMethodName(method.Name));
}
public override void Visit(IMethodImplementation methodImplementation)
{
if (Process(methodImplementation))
{
visitor.Visit(methodImplementation);
}
base.Visit(methodImplementation);
}
public static object GetExplicitInterfaceMethodNullableAttributeArgument(this IMethodImplementation methodImplementation, SRMetadataPEReaderCache metadataReaderCache)
{
if (methodImplementation != null)
{
uint typeToken = ((IMetadataObjectWithToken)methodImplementation.ContainingType).TokenValue;
string location = methodImplementation.ContainingType.Locations.FirstOrDefault()?.Document?.Location;
if (location != null)
{
return(methodImplementation.ImplementedMethod.ContainingType.GetInterfaceImplementationAttributeConstructorArgument(typeToken, location, metadataReaderCache, NullableConstructorArgumentParser));
}
}
return(null);
}
private void WritePropertyName(IPropertyDefinition property, IMethodDefinition accessor, bool isSetterAccessor, bool isIndexer)
{
if (property.IsExplicitInterfaceProperty())
{
IMethodImplementation methodImplementation = accessor.GetMethodImplementation();
object nullableAttributeArgument = methodImplementation.GetExplicitInterfaceMethodNullableAttributeArgument(_metadataReaderCache);
if (nullableAttributeArgument != null)
{
WriteTypeName(methodImplementation.ImplementedMethod.ContainingType, noSpace: true, nullableAttributeArgument: nullableAttributeArgument);
WriteSymbol(".");
if (isIndexer)
{
WriteIdentifier("this", false);
WriteIndexerParameters(accessor, isSetterAccessor);
}
else
{
string name = methodImplementation.ImplementedMethod.Name.Value;
WriteIdentifier(name.Substring(name.IndexOf("_") + 1));
}
return;
}
}
if (isIndexer)
{
int index = property.Name.Value.LastIndexOf(".");
if (index >= 0)
{
WriteIdentifier(property.Name.Value.Substring(0, index + 1) + "this", false); // +1 to include the '.'
}
else
{
WriteIdentifier("this", false);
}
WriteIndexerParameters(accessor, isSetterAccessor);
}
else
{
WriteIdentifier(property.Name);
}
}
public override List <IMethodImplementation> Rewrite(List <IMethodImplementation> methodImplementations)
{
TrimType currentType = CurrentTrimElement as TrimType;
List <IMethodImplementation> newList = new List <IMethodImplementation>();
if (methodImplementations == null)
{
return(newList);
}
foreach (IMethodImplementation methodImpl in methodImplementations)
{
IMethodReference implementingMethod = methodImpl.ImplementingMethod;
IMethodReference implementedMethod = methodImpl.ImplementedMethod;
TrimMember implementingMemberElement = currentType.GetMemberElementFromMember(implementingMethod);
TrimMember implementedMemberElement = null;
if (implementingMemberElement != null)
{
ITypeReference implementedType = Util.CanonicalizeTypeReference(implementedMethod.ContainingType);
TrimType implementedTypeElement = (TrimType)_currentTrimAssembly.GetTypeElement(Util.GetTypeName(implementedType));
if (implementedTypeElement != null)
{
implementedMemberElement = implementedTypeElement.GetMemberElementFromMember(Util.CanonicalizeMethodReference(implementedMethod));
}
}
else
{
}
if (implementingMemberElement != null && (implementedMemberElement != null ||
!_includeSet.Assemblies.ContainsKey(Util.GetDefiningAssembly(implementedMethod.ContainingType).Name.Value)))
{
IMethodImplementation newMethodImpl = Rewrite(methodImpl);
newList.Add(newMethodImpl);
}
//else
//{ Console.WriteLine("Removing {0}'s impl of {1}", implementingMethod.ToString(), implementedMethod.ToString()); }
}
return(newList);
}
internal static Tuple cil_method_stack_size(IMethodImplementation method, int stackSize) =>
new Tuple("cil_method_stack_size", method, stackSize);
internal static Tuple cil_method_implementation(IMethodImplementation impl, IMethod method, IAssembly assembly) =>
new Tuple("cil_method_implementation", impl, method, assembly);
internal static Tuple cil_local_variable(ILocal l, IMethodImplementation m, int i, Type t) =>
new Tuple("cil_local_variable", l, m, i, t);
//Constructs the form with an instance of IMethodImplementation
public Form1(IMethodImplementation addImplementation)
{
InitializeComponent();
AddImplementation = addImplementation;
}
public override void TraverseChildren(IMethodImplementation methodImplementation) {
base.TraverseChildren(methodImplementation);
}
//^ ensures this.path.Count == old(this.path.Count);
/// <summary>
/// Performs some computation with the given method implementation.
/// </summary>
/// <param name="methodImplementation"></param>
public virtual void Visit(IMethodImplementation methodImplementation)
{
if (this.stopTraversal) return;
//^ int oldCount = this.path.Count;
this.path.Push(methodImplementation);
this.Visit(methodImplementation.ImplementedMethod);
this.Visit(methodImplementation.ImplementingMethod);
//^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not decrease this.path.Count.
this.path.Pop();
}
public void Visit(IMethodImplementation methodImplementation)
{
Contract.Assume(false);
}
public override void TraverseChildren(IMethodImplementation methodImplementation)
{ MethodEnter(methodImplementation);
base.TraverseChildren(methodImplementation);
MethodExit(); }
public virtual void onMetadataElement(IMethodImplementation methodImplementation)
{
}
public virtual void Visit(IMethodImplementation methodImplementation)
{
this.Visit(methodImplementation.ImplementedMethod);
this.Visit(methodImplementation.ImplementingMethod);
}
/// <summary>
/// Performs some computation with the given method implementation.
/// </summary>
public virtual void Visit(IMethodImplementation methodImplementation)
{
}
public virtual void Visit(IMethodImplementation methodImplementation)
{
this.Visit(methodImplementation.ImplementedMethod);
this.Visit(methodImplementation.ImplementingMethod);
}
/// <summary>
/// Rewrites the given method implementation.
/// </summary>
public virtual IMethodImplementation Rewrite(IMethodImplementation methodImplementation)
{
return methodImplementation;
}
/// <summary>
/// Traverses the method implementation.
/// </summary>
public void Traverse(IMethodImplementation methodImplementation)
{
Contract.Requires(methodImplementation != null);
if (this.preorderVisitor != null) this.preorderVisitor.Visit(methodImplementation);
this.Traverse(methodImplementation.ImplementedMethod);
if (this.stopTraversal) return;
this.Traverse(methodImplementation.ImplementingMethod);
if (this.stopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(methodImplementation);
}
public void Visit(IMethodImplementation methodImplementation)
{
throw new NotImplementedException();
}
/// <summary>
/// Traverses the children of the method implementation.
/// </summary>
public virtual void TraverseChildren(IMethodImplementation methodImplementation)
{
Contract.Requires(methodImplementation != null);
this.Traverse(methodImplementation.ImplementedMethod);
if (this.stopTraversal) return;
this.Traverse(methodImplementation.ImplementingMethod);
}
public override void TraverseChildren(IMethodImplementation methodImplementation)
{
MethodEnter(methodImplementation);
base.TraverseChildren(methodImplementation);
MethodExit();
}
/// <summary>
/// Performs some computation with the given method implementation.
/// </summary>
public virtual void Visit(IMethodImplementation methodImplementation)
{
}
public override void Visit(IMethodImplementation methodImplementation)
{
if(Process(methodImplementation)){visitor.Visit(methodImplementation);}
base.Visit(methodImplementation);
}
/// <summary>
/// Performs some computation with the given method implementation.
/// </summary>
public void Visit(IMethodImplementation methodImplementation)
{
if (methodImplementation.ContainingType is Dummy)
this.ReportError(MetadataError.IncompleteNode, methodImplementation, "ContainingType");
if (methodImplementation.ImplementedMethod is Dummy)
this.ReportError(MetadataError.IncompleteNode, methodImplementation, "ImplementedMethod");
if (methodImplementation.ImplementingMethod is Dummy)
this.ReportError(MetadataError.IncompleteNode, methodImplementation, "ImplementingMethod");
var resolvedImplementedMethod = methodImplementation.ImplementedMethod.ResolvedMethod;
if (resolvedImplementedMethod != Dummy.Method) {
if (!resolvedImplementedMethod.IsVirtual || resolvedImplementedMethod.IsSealed || resolvedImplementedMethod.ContainingTypeDefinition.IsSealed)
this.ReportError(MetadataError.MethodCannotBeAnOverride, resolvedImplementedMethod, methodImplementation);
if (resolvedImplementedMethod.IsAccessCheckedOnOverride) {
switch (resolvedImplementedMethod.Visibility) {
case TypeMemberVisibility.Public:
case TypeMemberVisibility.Family:
case TypeMemberVisibility.FamilyOrAssembly:
break;
case TypeMemberVisibility.Assembly:
case TypeMemberVisibility.FamilyAndAssembly:
var implementedUnit = TypeHelper.GetDefiningUnit(resolvedImplementedMethod.ContainingTypeDefinition);
if (implementedUnit is Dummy) break; //Complaining might be a false positive. Wait until runtime.
if (implementedUnit.UnitIdentity.Equals(this.validator.currentModule.ModuleIdentity)) break;
var implementingAssembly = this.validator.currentModule as IAssembly;
var implementedAssembly = implementedUnit as IAssembly;
if (implementingAssembly != null && implementedAssembly != null &&
UnitHelper.AssemblyOneAllowsAssemblyTwoToAccessItsInternals(implementedAssembly, implementingAssembly))
break;
goto default;
default:
this.ReportError(MetadataError.MayNotOverrideInaccessibleMethod, resolvedImplementedMethod, methodImplementation);
break;
}
}
}
//check that implemented method is inherited from a base class or interface
//check for local or inherited implementer
var resolvedImplementingMethod = methodImplementation.ImplementingMethod.ResolvedMethod;
if (resolvedImplementedMethod != Dummy.Method) {
if (!(resolvedImplementedMethod.IsVirtual || resolvedImplementedMethod.IsAbstract || resolvedImplementedMethod.IsExternal))
this.ReportError(MetadataError.MethodCannotBeAnOverride, resolvedImplementedMethod, methodImplementation);
}
if (methodImplementation.ImplementingMethod.IsGeneric) {
if (!MemberHelper.GenericMethodSignaturesAreEqual(methodImplementation.ImplementedMethod, methodImplementation.ImplementingMethod))
this.ReportError(MetadataError.ExplicitOverrideDoesNotMatchSignatureOfOverriddenMethod, methodImplementation);
} else {
if (!MemberHelper.SignaturesAreEqual(methodImplementation.ImplementedMethod, methodImplementation.ImplementingMethod))
this.ReportError(MetadataError.ExplicitOverrideDoesNotMatchSignatureOfOverriddenMethod, methodImplementation);
}
}
internal static Tuple cil_instruction(IInstruction instruction, int opcode, int index, IMethodImplementation parent) =>
new Tuple("cil_instruction", instruction, opcode, index, parent);
public virtual void onMetadataElement(IMethodImplementation methodImplementation) { }
public override void Visit(IMethodImplementation methodImplementation)
{
allElements.Add(new InvokInfo(Traverser, "IMethodImplementation", methodImplementation));
}
internal static Tuple cil_handler(IExceptionRegion region, IMethodImplementation method, int index, int kind,
IInstruction region_start,
IInstruction region_end,
IInstruction handler_start) =>
new Tuple("cil_handler", region, method, index, kind, region_start, region_end, handler_start);
/// <summary>
/// Traverses the children of the method implementation.
/// </summary>
public virtual void TraverseChildren(IMethodImplementation methodImplementation)
{
this.Traverse(methodImplementation.ImplementedMethod);
if (this.stopTraversal) return;
this.Traverse(methodImplementation.ImplementingMethod);
}