public bool TryGetPropertyAccessorReferences(CSharpMember semanticProperty, out IMethodReference getter, out IMethodReference setter)
{
Contract.Requires(semanticProperty == null || semanticProperty.IsProperty || semanticProperty.IsIndexer);
getter = setter = null;
#region Check input
if (semanticProperty == null)
{
return(false);
}
#endregion
#region Check cache
Tuple <IMethodReference, IMethodReference> cacheOutput;
if (_semanticPropertiesToCCIAccessorMethods.TryGetValue(semanticProperty, out cacheOutput))
{
Contract.Assume(cacheOutput != null, "Non-null only dictionary");
getter = cacheOutput.Item1;
setter = cacheOutput.Item2;
return((getter != null && getter != Dummy.MethodReference) || (setter != null && setter != Dummy.MethodReference));
}
#endregion
#region Get calling conventions
var callingConventions = CSharpToCCIHelper.GetCallingConventionFor(semanticProperty);
#endregion
#region get containing type
ITypeReference containingType;
if (!TryGetTypeReference(semanticProperty.ContainingType, out containingType))
{
goto ReturnFalse;
}
#endregion
#region Get return type
ITypeReference returnType;
if (!TryGetTypeReference(semanticProperty.ReturnType, out returnType))
{
goto ReturnFalse;
}
#endregion
#region Get the property's name
string propertyName;
if (semanticProperty.IsIndexer)
{
propertyName = "Item";
}
else
{
if (semanticProperty.Name == null)
{
goto ReturnFalse;
}
propertyName = semanticProperty.Name.Text;
}
#endregion
#region Get the parameters
List <IParameterTypeInformation> getterParams;
if (semanticProperty.Parameters != null)
{
if (!TryGetParametersList(semanticProperty.Parameters, out getterParams))
{
goto ReturnFalse;
}
}
else
{
getterParams = new List <IParameterTypeInformation>();
}
List <IParameterTypeInformation> setterParams;
if (semanticProperty.Parameters != null)
{
if (!TryGetParametersList(semanticProperty.Parameters, out setterParams, 1))
{
goto ReturnFalse;
}
#region Append the "value" param
var valParam = new Microsoft.Cci.MutableCodeModel.ParameterTypeInformation()
{
Type = returnType,
Index = 0,
IsByReference = false
};
setterParams.Insert(0, valParam);
#endregion
}
else
{
setterParams = new List <IParameterTypeInformation>();
}
#endregion
#region Build the getter
getter = new Microsoft.Cci.MutableCodeModel.MethodReference()
{
InternFactory = Host.InternFactory,
CallingConvention = callingConventions,
ContainingType = containingType,
Type = returnType,
Name = Host.NameTable.GetNameFor("get_" + propertyName),
GenericParameterCount = 0,
Parameters = getterParams
};
#endregion
#region Build the setter
setter = new Microsoft.Cci.MutableCodeModel.MethodReference()
{
InternFactory = Host.InternFactory,
CallingConvention = callingConventions,
ContainingType = containingType,
Type = Host.PlatformType.SystemVoid,
Name = Host.NameTable.GetNameFor("set_" + propertyName),
GenericParameterCount = 0,
Parameters = setterParams
};
#endregion
#region Get the assembly reference (this also ensures the assembly gets loaded properly)
IAssemblyReference assemblyReference;
TryGetAssemblyReference(semanticProperty.Assembly, out assemblyReference);
#endregion
#region ReturnTrue:
//ReturnTrue:
_semanticPropertiesToCCIAccessorMethods[semanticProperty] = new Tuple <IMethodReference, IMethodReference>(getter, setter);
return(true);
#endregion
#region ReturnFalse:
ReturnFalse:
if (semanticProperty.Name != null)
{
ContractsPackageAccessor.Current.Logger.WriteToLog("Failed to build accessor references for: " + semanticProperty.Name.Text);
}
_semanticPropertiesToCCIAccessorMethods[semanticProperty] = new Tuple <IMethodReference, IMethodReference>(Dummy.MethodReference, Dummy.MethodReference);
return(false);
#endregion
}
public bool TryGetMethodReference(CSharpMember semanticMethod, out IMethodReference cciMethod)
{
Contract.Requires(semanticMethod == null || semanticMethod.IsConstructor || semanticMethod.IsMethod);
Contract.Ensures(!Contract.Result <bool>() || Contract.ValueAtReturn(out cciMethod) != null);
cciMethod = null;
#region Check input
if (semanticMethod == null)
{
return(false);
}
#endregion
#region Check cache
if (ContractsPackageAccessor.Current.VSOptionsPage.Caching)
{
if (_semanticMembersToCCIMethods.TryGetValue(semanticMethod, out cciMethod))
{
return((!(cciMethod is Dummy)) && cciMethod != null);
}
}
#endregion
#region Set up our working cci method
var workingCciMethod = new Microsoft.Cci.MutableCodeModel.MethodReference();
#endregion
#region Set the intern factory
workingCciMethod.InternFactory = Host.InternFactory;
#endregion
#region Get calling conventions
workingCciMethod.CallingConvention = CSharpToCCIHelper.GetCallingConventionFor(semanticMethod);
#endregion
#region Get containing type reference
ITypeReference containingType;
if (!TryGetTypeReference(semanticMethod.ContainingType, out containingType))
{
goto ReturnFalse;
}
workingCciMethod.ContainingType = containingType;
#endregion
#region Get return type reference
if (semanticMethod.IsConstructor)
{
workingCciMethod.Type = this.Host.PlatformType.SystemVoid;
}
else
{
ITypeReference returnType;
if (!TryGetTypeReference(semanticMethod.ReturnType, out returnType))
{
goto ReturnFalse;
}
workingCciMethod.Type = returnType;
}
#endregion
#region Get name
if (!semanticMethod.IsConstructor && semanticMethod.Name == null)
{
goto ReturnFalse;
}
workingCciMethod.Name = Host.NameTable.GetNameFor(semanticMethod.IsConstructor?".ctor":semanticMethod.Name.Text);
#endregion
#region Get generic param count
if (semanticMethod.TypeParameters == null)
{
workingCciMethod.GenericParameterCount = 0;
}
else
{
workingCciMethod.GenericParameterCount = (ushort)semanticMethod.TypeParameters.Count;
}
#endregion
#region Get parameter references
List <IParameterTypeInformation> cciParameters;
if (semanticMethod.Parameters == null)
{
goto ReturnFalse;
}
Contract.Assume(semanticMethod.Parameters.Count <= ushort.MaxValue, "Should be a postcondition?");
if (!TryGetParametersList(semanticMethod.Parameters, out cciParameters))
{
goto ReturnFalse;
}
workingCciMethod.Parameters = cciParameters;
#endregion
#region Get the assembly reference (this also ensures the assembly gets loaded properly)
IAssemblyReference assemblyReference;
TryGetAssemblyReference(semanticMethod.Assembly, out assemblyReference);
#endregion
cciMethod = workingCciMethod;
return(true);
#region ReturnFalse:
ReturnFalse:
cciMethod = Dummy.MethodReference;
if (ContractsPackageAccessor.Current.VSOptionsPage.Caching)
{
_semanticMembersToCCIMethods[semanticMethod] = cciMethod;
}
return(false);
#endregion
}