int IMethodSignatureMemberDictionary.IndexOf(IMethodSignatureMember method)
{
if (!(method is TSignature))
{
return(-1);
}
return(this.IndexOf((TSignature)(method)));
}
public int IndexOf(IMethodSignatureMember method)
{
int valueIndex = this.master.Values.IndexOf(new MasterDictionaryEntry <IMember>(this, method));
if (valueIndex == -1)
{
return(-1);
}
return(this.identifiers.GetIndexOf(master.Keys[valueIndex]));
}
void _onAddMethod_Disposed(object sender, EventArgs e)
{
if (this._onAddMethod != null)
{
_onAddMethod.Disposed -= new EventHandler(_onAddMethod_Disposed);
this._onAddMethod = null;
}
if (this.onAddMethod != null)
{
this.onAddMethod.Dispose();
this.onAddMethod = null;
}
}
public void ReferenceDeclaration(IMethodSignatureMember declaration)
{
if (declaration is IIntermediateMethodMember)
{
this.ReferenceDeclaration((IIntermediateMethodMember)declaration);
}
else if (declaration is IIntermediateMethodSignatureMember)
{
this.ReferenceDeclaration((IIntermediateMethodSignatureMember)declaration);
}
else
{
this.Formatter.ReferenceDeclaration(declaration);
}
}
public virtual void TranslateMember(IMethodSignatureMember methodSigMember)
{
this.TranslateMember <IMethodSignatureParameterMember, IMethodSignatureTypeParameterMember, CodeMemberMethod, ISignatureMemberParentType>(methodSigMember);
}
public void RegisterGenericMethod(IMethodSignatureMember targetSignature, IControlledTypeCollection typeParameters)
{
this.CheckGenericCache();
this.genericCache.RegisterGenericMethod(targetSignature, typeParameters);
}
public void RegisterGenericChild(IMethodSignatureParent parent, IMethodSignatureMember genericChild)
{
throw new NotSupportedException();
}
public MethodSignatureTypeParameterMember(string name, IMethodSignatureMember parentTarget)
: base(name, parentTarget)
{
}
public void RegisterGenericChild(IMethodSignatureParent parent, IMethodSignatureMember genericChild)
{
this.CheckGenericCache();
this.genericCache.RegisterGenericChild(parent, genericChild);
}
public override void TranslateMember <TParameter, TTypeParameter, TSignatureDom, TParent>(IMethodSignatureMember <TParameter, TTypeParameter, TSignatureDom, TParent> ambigMethodSigMember)
{
this.Provider.GenerateCodeFromMember((CodeMemberMethod)ambigMethodSigMember.GenerateCodeDom(Options), base.Target, this.Options.Options);
}
protected override IMethodSignatureMember OnGetMethod(IMethodSignatureMember original)
{
return(new _MethodsBase._Method(this.Parent, (IInterfaceMethodMember)original));
}
protected abstract IMethodSignatureMember OnGetMethod(IMethodSignatureMember original);
public void ReferenceDeclaration(IMethodSignatureMember declaration)
{
}
public abstract void TranslateMember <TParameter, TTypeParameter, TSignatureDom, TParent>(IMethodSignatureMember <TParameter, TTypeParameter, TSignatureDom, TParent> ambigMethodSigMember)
where TParameter :
IParameteredParameterMember <TParameter, TSignatureDom, TParent>
where TTypeParameter :
IMethodSignatureTypeParameterMember <TParameter, TTypeParameter, TSignatureDom, TParent>
where TSignatureDom :
CodeMemberMethod,
new()
where TParent :
IDeclarationTarget;
protected override IMembers <IMethodTypeParameterMember, IMethodSignatureMember <IMethodParameterMember, IMethodTypeParameterMember, CodeMemberMethod, IMemberParentType>, CodeTypeParameter> OnGetPartialClone(IMethodSignatureMember <IMethodParameterMember, IMethodTypeParameterMember, CodeMemberMethod, IMemberParentType> parent)
{
throw new NotSupportedException("Method Type-parameters cannot be spanned across multiple instances");
}
//#region ITypeIdentityManager<ICliMetadataTypeSpecificationTableRow> Members
public IType ObtainTypeReference(ICliMetadataTypeSpecificationTableRow typeIdentity, IType activeType, IMethodSignatureMember activeMethod, IAssembly activeAssembly = null)
{
if (typeIdentity.Signature is ICliMetadataTypeSignature)
{
return(this.ObtainTypeReference((ICliMetadataTypeSignature)typeIdentity.Signature, activeType, activeMethod, activeAssembly));
}
throw new NotSupportedException();
}
public MethodSignatureParameterMembers(IMethodSignatureMember targetDeclaration)
: base(targetDeclaration)
{
}
public static int CalculateStackRequirement <TSignatureParameter, TSignature, TSignatureParent>(this IMethodSignatureMember <TSignatureParameter, TSignature, TSignatureParent> method)
where TSignatureParameter :
IMethodSignatureParameterMember <TSignatureParameter, TSignature, TSignatureParent>
where TSignature :
IMethodSignatureMember <TSignatureParameter, TSignature, TSignatureParent>
where TSignatureParent :
ISignatureParent <IGeneralGenericSignatureMemberUniqueIdentifier, TSignature, TSignatureParameter, TSignatureParent>
{
var extendedInstanceMember = method as IExtendedInstanceMember;
if (extendedInstanceMember != null)
{
if (extendedInstanceMember.IsStatic)
{
return(method.Parameters.Count);
}
else
{
return(method.Parameters.Count + 1);
}
}
return(method.Parameters.Count);
}
/// <summary>
/// Creates a new instance of <see cref="MethodSignatureParameterMember"/>
/// with the parameter type, name and target provided.
/// </summary>
/// <param name="nameAndType">The type and name of the parameter.</param>
/// <param name="parentTarget">The place the parameter exists on.</param>
public MethodSignatureParameterMember(TypedName nameAndType, IMethodSignatureMember parentTarget)
: base(nameAndType, parentTarget)
{
}
public CliSignatureTypeCollection(_ICliManager manager, ICliMetadataMethodSignature signature, IType activeType, IMethodSignatureMember activeMethod)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
if (signature == null)
{
throw new ArgumentNullException("signature");
}
this.manager = manager;
this.signatureTypes = new IType[signature.Parameters.Count];
this.ActiveType = activeType;
this.ActiveMethod = activeMethod;
this.signature = signature;
}
public CliParameterMemberDictionary(_ICliManager manager, uint methodIndex, ICliMetadataRoot metadataRoot, TParent parent, IMethodSignatureMember activeMethod)
: this(manager, methodIndex, metadataRoot, parent)
{
this.activeMethod = activeMethod;
}
protected sealed override IMethodSignatureMember OnGetMethod(IMethodSignatureMember original)
{
return(this.OnGetMethod(((IMethodMember)(original))));
}
public void ReferenceDeclaration(IMethodSignatureMember declaration)
{
referenceStack.Push(declaration);
}
/// <summary><para>Creates a C♯ compiler warning, relative to the
/// abstract model, (level 2) #280:</para><para><paramref name="offendingType"/> does not implement the <paramref name="patternName"/>. <paramref name="offendingMethod"/> has the wrong signature.</para></summary>
public static ICompilerSourceModelWarning <IExpression, IType, string, IMethodSignatureMember> WarningCS0280(IExpression offendingExpression, IType offendingType, string patternName, IMethodSignatureMember offendingMethod)
{
var start = offendingExpression.Start ?? LineColumnPair.Zero;
var end = offendingExpression.End ?? LineColumnPair.Zero;
return(new CompilerSourceModelWarning <IExpression, IType, string, IMethodSignatureMember>(CS0280, offendingExpression, offendingType, patternName, offendingMethod, offendingExpression.Location, start, end, offendingType.UniqueIdentifier.ToString(), patternName, offendingMethod.UniqueIdentifier.ToString()));
}
internal static IEnumerable <IInterfaceType> GetImplementations(ICliMetadataTypeDefinitionTableRow parentDef, ICliMetadataMethodDefinitionTableRow methodMetadata, CliManager identityManager, IType activeType, IMethodSignatureMember activeMethod, IAssembly activeAssembly)
{
var targets = (from t in parentDef.ImplementationMap
where t.MethodBody == methodMetadata
select t.MethodDeclaration);
foreach (var target in targets)
{
IType currentType = null;
switch (target.MethodDefOrRefEncoding)
{
case CliMetadataMethodDefOrRefTag.MethodDefinition:
ICliMetadataMethodDefinitionTableRow methodDef = (ICliMetadataMethodDefinitionTableRow)target;
currentType = identityManager.ObtainTypeReference(methodMetadata.MetadataRoot.TableStream.TypeDefinitionTable[(int)methodMetadata.MetadataRoot.TableStream.TypeDefinitionTable.GetTypeFromMethodIndex(methodDef.Index)], activeType, activeMethod, activeAssembly);
break;
case CliMetadataMethodDefOrRefTag.MemberRef:
ICliMetadataMemberReferenceTableRow memberRef = (ICliMetadataMemberReferenceTableRow)target;
switch (memberRef.ClassSource)
{
case CliMetadataMemberRefParentTag.TypeDefinition:
currentType = identityManager.ObtainTypeReference((ICliMetadataTypeDefinitionTableRow)memberRef.Class, activeType, activeMethod, activeAssembly);
break;
case CliMetadataMemberRefParentTag.TypeReference:
currentType = identityManager.ObtainTypeReference((ICliMetadataTypeRefTableRow)memberRef.Class, activeType, activeMethod, activeAssembly);
break;
case CliMetadataMemberRefParentTag.TypeSpecification:
currentType = identityManager.ObtainTypeReference((ICliMetadataTypeSpecificationTableRow)memberRef.Class, activeType, activeMethod, activeAssembly);
break;
}
break;
}
if (currentType != null && currentType is IInterfaceType)
{
yield return((IInterfaceType)currentType);
}
}
}
