public override void TraverseChildren(IParameterDefinition parameterDefinition)
{
PrintParameterDefinitionModifiers(parameterDefinition);
PrintParameterDefinitionType(parameterDefinition);
PrintToken(CSharpToken.Space);
PrintParameterDefinitionName(parameterDefinition);
}
private static void Ldarg(ILGenerator ilGenerator, IParameterDefinition parameter, int i)
{
switch (i)
{
case 0:
ilGenerator.Emit(OperationCode.Ldarg_0);
break;
case 1:
ilGenerator.Emit(OperationCode.Ldarg_1);
break;
case 2:
ilGenerator.Emit(OperationCode.Ldarg_2);
break;
case 3:
ilGenerator.Emit(OperationCode.Ldarg_3);
break;
default:
ilGenerator.Emit(i <= byte.MaxValue ? OperationCode.Ldarg_S : OperationCode.Ldarg, parameter);
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="parameter"></param>
protected void LoadParameter(IParameterDefinition /*?*/ parameter)
{
ushort parIndex = GetParameterIndex(parameter);
if (parIndex == 0)
{
this.ilGenerator.Emit(OperationCode.Ldarg_0, parameter);
}
else if (parIndex == 1)
{
this.ilGenerator.Emit(OperationCode.Ldarg_1, parameter);
}
else if (parIndex == 2)
{
this.ilGenerator.Emit(OperationCode.Ldarg_2, parameter);
}
else if (parIndex == 3)
{
this.ilGenerator.Emit(OperationCode.Ldarg_3, parameter);
}
else if (parIndex <= byte.MaxValue)
{
this.ilGenerator.Emit(OperationCode.Ldarg_S, parameter);
}
else
{
this.ilGenerator.Emit(OperationCode.Ldarg, parameter);
}
}
private bool ParamNamesMatch(IDifferences differences, IMethodDefinition implMethod, IMethodDefinition contractMethod)
{
int paramCount = implMethod.ParameterCount;
Contract.Assert(paramCount == contractMethod.ParameterCount);
IParameterDefinition[] implParams = implMethod.Parameters.ToArray();
IParameterDefinition[] contractParams = contractMethod.Parameters.ToArray();
bool match = true;
for (int i = 0; i < paramCount; i++)
{
IParameterDefinition implParam = implParams[i];
IParameterDefinition contractParam = contractParams[i];
if (!implParam.Name.Value.Equals(contractParam.Name.Value))
{
differences.AddIncompatibleDifference(this,
"Parameter name on member '{0}' is '{1}' in the implementation but '{2}' in the contract.",
implMethod.FullName(), implParam.Name.Value, contractParam.Name.Value);
match = false;
}
}
return(match);
}
public virtual void Visit(IParameterDefinition parameterDefinition)
{
var marshalling = parameterDefinition.MarshallingInformation;
Debug.Assert((marshalling != null || !parameterDefinition.MarshallingDescriptor.IsDefaultOrEmpty) == parameterDefinition.IsMarshalledExplicitly);
this.Visit(parameterDefinition.GetAttributes(Context));
this.Visit(parameterDefinition.CustomModifiers);
IMetadataConstant defaultValue = parameterDefinition.GetDefaultValue(Context);
if (defaultValue != null)
{
this.Visit((IMetadataExpression)defaultValue);
}
if (marshalling != null)
{
// Note, we are not visiting MarshallingDescriptor. It is used only for
// NoPia embedded/local types and VB Dev11 simply copies the bits without
// cracking them.
this.Visit(marshalling);
}
this.Visit(parameterDefinition.GetType(Context));
}
/// <summary>
/// Appends a formatted parameters.
/// </summary>
protected virtual void AppendParameter(IParameterTypeInformation param, NameFormattingOptions formattingOptions, StringBuilder sb)
{
IParameterDefinition def = param as IParameterDefinition;
if (def != null && (formattingOptions & NameFormattingOptions.ParameterModifiers) != 0)
{
if (def.IsOut)
{
sb.Append("out ");
}
else if (def.IsParameterArray)
{
sb.Append("params ");
}
else if (def.IsByReference)
{
sb.Append("ref ");
}
}
sb.Append(_typeNameFormatter.GetTypeName(param.Type, formattingOptions));
if (def != null && (formattingOptions & NameFormattingOptions.ParameterName) != 0)
{
sb.Append(" ");
sb.Append(def.Name.Value);
}
}
public virtual void PrintParameterDefinitionModifiers(IParameterDefinition parameterDefinition) {
Contract.Requires(parameterDefinition != null);
if (parameterDefinition.Index == 0) {
var meth = parameterDefinition.ContainingSignature as IMethodDefinition;
if (meth != null ) {
if (Utils.FindAttribute(meth.Attributes, SpecialAttribute.Extension) != null) {
PrintToken(CSharpToken.This);
PrintToken(CSharpToken.Space);
}
}
}
foreach (var attribute in SortAttributes(parameterDefinition.Attributes)) {
if (Utils.GetAttributeType(attribute) == SpecialAttribute.ParamArray)
sourceEmitterOutput.Write("params");
else
this.PrintAttribute(parameterDefinition, attribute, false, null);
PrintToken(CSharpToken.Space);
}
if (parameterDefinition.IsOut && !parameterDefinition.IsIn && parameterDefinition.IsByReference) {
// C# out keyword means [Out] ref (with no [In] allowed)
PrintKeywordOut();
} else {
if (parameterDefinition.IsIn)
PrintPseudoCustomAttribute(parameterDefinition, "System.Runtime.InteropServices.In", null, false, null);
if (parameterDefinition.IsOut)
PrintPseudoCustomAttribute(parameterDefinition, "System.Runtime.InteropServices.Out", null, false, null);
if (parameterDefinition.IsByReference)
PrintKeywordRef();
}
}
private bool ParamNamesAndTypesMatch(IDifferences differences, IMethodDefinition implMethod, IMethodDefinition contractMethod)
{
int paramCount = implMethod.ParameterCount;
Debug.Assert(paramCount == contractMethod.ParameterCount);
IParameterDefinition[] implParams = implMethod.Parameters.ToArray();
IParameterDefinition[] contractParams = contractMethod.Parameters.ToArray();
bool match = true;
for (int i = 0; i < paramCount; i++)
{
IParameterDefinition implParam = implParams[i];
IParameterDefinition contractParam = contractParams[i];
if (!implParam.Name.Value.Equals(contractParam.Name.Value))
{
differences.AddIncompatibleDifference("DelegateParamNameMustMatch",
$"Parameter name on delegate '{implMethod.ContainingType.FullName()}' is '{implParam.Name.Value}' in the {Implementation} but '{contractParam.Name.Value}' in the {Contract}.");
match = false;
}
if (!_typeComparer.Equals(implParam.Type, contractParam.Type))
{
differences.AddTypeMismatchDifference("DelegateParamTypeMustMatch", implParam.Type, contractParam.Type,
$"Type for parameter '{implParam.Name.Value}' on delegate '{implMethod.ContainingType.FullName()}' is '{implParam.Type.FullName()}' in the {Implementation} but '{contractParam.Type.FullName()}' in the {Contract}.");
match = false;
}
}
return(match);
}
public override object RewriteReference(IParameterDefinition parameterDefinition)
{
var mappedParameter = this.parameterMap.Find((uint)parameterDefinition.Name.UniqueKey);
Contract.Assume(mappedParameter != null);
return(mappedParameter);
}
public static bool CompareParameterName(IParameterDefinition parameter, string name, bool useCase)
{
return(name.Equals(parameter.Name,
useCase ? StringComparison.InvariantCultureIgnoreCase : StringComparison.InvariantCulture) ||
name.Equals(parameter.ShortName,
useCase ? StringComparison.InvariantCultureIgnoreCase : StringComparison.InvariantCulture));
}
public override void TraverseChildren(IParameterDefinition parameterDefinition) {
PrintParameterDefinitionModifiers(parameterDefinition);
PrintParameterDefinitionName(parameterDefinition);
PrintToken(VBToken.Space);
PrintToken(VBToken.As);
PrintToken(VBToken.Space);
PrintParameterDefinitionType(parameterDefinition);
}
public static void DisplayCommandParameter(TriggerBase trigger, IParameterDefinition parameter)
{
trigger.Reply("\t(" + trigger.Bold("{0}") + " : {1})", new object[]
{
parameter.GetUsage(),
parameter.Description ?? ""
});
}
public override void VisitReference(IParameterDefinition parameterDefinition)
{
if (Process(parameterDefinition))
{
visitor.Visit(parameterDefinition);
}
base.VisitReference(parameterDefinition);
}
public override void TraverseChildren(ITargetExpression targetExpression)
{
base.TraverseChildren(targetExpression);
ITypeReference type = Dummy.TypeReference;
ILocalDefinition /*?*/ local = targetExpression.Definition as ILocalDefinition;
if (local != null)
{
if (local.IsReference)
{
if (local.IsPinned)
{
type = Immutable.PointerType.GetPointerType(local.Type, this.host.InternFactory);
}
else
{
type = Immutable.ManagedPointerType.GetManagedPointerType(local.Type, this.host.InternFactory);
}
}
else
{
type = local.Type;
}
}
else
{
IParameterDefinition /*?*/ parameter = targetExpression.Definition as IParameterDefinition;
if (parameter != null)
{
type = parameter.Type;
}
else
{
IFieldReference /*?*/ field = targetExpression.Definition as IFieldReference;
if (field != null)
{
type = field.Type;
}
else
{
IPropertyDefinition /*?*/ property = targetExpression.Definition as IPropertyDefinition;
if (property != null)
{
type = property.Type;
}
else
{
IExpression /*?*/ expression = targetExpression.Definition as IExpression;
if (expression != null)
{
type = expression.Type;
}
}
}
}
}
((TargetExpression)targetExpression).Type = type;
}
private bool CheckModifiersOnParametersAndReturnValue(IDifferences differences, IMethodDefinition implMethod, IMethodDefinition contractMethod)
{
int paramCount = implMethod.ParameterCount;
Contract.Assert(paramCount == contractMethod.ParameterCount);
if (paramCount == 0)
{
return(true);
}
IParameterDefinition[] implParams = implMethod.Parameters.ToArray();
IParameterDefinition[] contractParams = contractMethod.Parameters.ToArray();
bool match = true;
for (int i = 0; i < paramCount; i++)
{
IParameterDefinition implParam = implParams[i];
IParameterDefinition contractParam = contractParams[i];
//TODO: Do we care about the compatibility with marshalling attributes Out\In? They don't seem to be set consistently.
if (GetModifier(implParam) != GetModifier(contractParam))
{
differences.AddIncompatibleDifference(this,
"Modifiers on parameter '{0}' on method '{1}' are '{2}' in the implementation but '{3}' in the contract.",
implParam.Name.Value, implMethod.FullName(), GetModifier(implParam), GetModifier(contractParam));
match = false;
}
// Now check custom modifiers, primarily focused on const & volatile
if (implParam.IsModified || contractParam.IsModified)
{
var union = implParam.CustomModifiers.Union(contractParam.CustomModifiers);
if (implParam.CustomModifiers.Count() != union.Count())
{
differences.AddIncompatibleDifference(this,
"Custom modifiers on parameter '{0}' on method '{1}' are '{2}' in the implementation but '{3}' in the contract.",
implParam.Name.Value, implMethod.FullName(), PrintCustomModifiers(implParam.CustomModifiers), PrintCustomModifiers(contractParam.CustomModifiers));
match = false;
}
}
}
string implReturnModifier = GetReturnValueModifier(implMethod);
string contractReturnModifier = GetReturnValueModifier(contractMethod);
if (implReturnModifier != contractReturnModifier)
{
differences.AddIncompatibleDifference(this,
"Modifiers on return type of method '{0}' are '{1}' in the implementation but '{2}' in the contract.",
implMethod.FullName(), implReturnModifier, contractReturnModifier);
match = false;
}
return(match);
}
public ParameterDefinition(IParameterDefinition copyFrom) : base(copyFrom)
{
Context = copyFrom.Context;
DataType = copyFrom.DataType;
IsRequired = copyFrom.IsRequired;
IsVariadic = copyFrom.IsVariadic;
Name = copyFrom.Name;
Type = copyFrom.Type;
}
public ParameterDefinition(IParameterDefinition copyFrom) : base(copyFrom)
{
Context = copyFrom.Context;
DataType = copyFrom.DataType;
IsRequired = copyFrom.IsRequired;
IsVariadic = copyFrom.IsVariadic;
Name = copyFrom.Name;
Type = copyFrom.Type;
}
private string GetModifier(IParameterDefinition parameter)
{
if (parameter.IsOut && !parameter.IsIn && parameter.IsByReference)
return "out";
else if (parameter.IsByReference)
return "ref";
return "in";
}
IEnumerable <IContractElement> GetReleventContracts <TContractElement>(IParameterDefinition parameter, IEnumerable <TContractElement> contractElements) where TContractElement : IContractElement
{
Contract.Requires(parameter != null);
Contract.Requires(contractElements != null);
return(from contractElement in contractElements
where (contractElement as IContractElement).OriginalSource.Contains(parameter.Name.Value)
select(contractElement as IContractElement));
}
public CciParameterDetails(IParameterDefinition parameter)
{
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
_parameter = parameter;
}
public CciParameterDetails(IParameterDefinition parameter)
{
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
_parameter = parameter;
}
public override IParameterDefinition Rewrite(IParameterDefinition parameterDefinition)
{
//we need to copy the parameters because they still come from the closure method.
var copy = new ParameterDefinition();
copy.Copy(parameterDefinition, this.host.InternFactory);
copy.ContainingSignature = this.anonymousDelegate;
this.parameterMap.Add((uint)parameterDefinition.Name.UniqueKey, copy);
return(copy);
}
/// <summary>
///
/// </summary>
/// <param name="parameter"></param>
protected void LoadParameterAddress(IParameterDefinition /*?*/ parameter)
{
ushort parIndex = GetParameterIndex(parameter);
if (parIndex <= byte.MaxValue)
{
this.ilGenerator.Emit(OperationCode.Ldarga_S, parameter);
}
else
{
this.ilGenerator.Emit(OperationCode.Ldarga, parameter);
}
}
/// <summary>
///
/// </summary>
/// <param name="parameter"></param>
protected void StoreParameter(IParameterDefinition /*?*/ parameter)
{
ushort parIndex = GetParameterIndex(parameter);
if (parIndex <= byte.MaxValue)
{
this.ilGenerator.Emit(OperationCode.Starg_S, parameter);
}
else
{
this.ilGenerator.Emit(OperationCode.Starg, parameter);
}
}
/// <summary>
/// Puts the specified instruction onto the Microsoft intermediate language (MSIL) stream followed by the index of the given local variable.
/// </summary>
/// <param name="opcode">The Microsoft intermediate language (MSIL) instruction to be put onto the stream.</param>
/// <param name="parameter">A parameter definition.</param>
public void Emit(OperationCode opcode, IParameterDefinition parameter)
{
this.operations.Add(new Operation(opcode, this.offset, this.GetCurrentSequencePoint(), parameter));
this.offset += SizeOfOperationCode(opcode);
if (opcode == OperationCode.Ldarg_S || opcode == OperationCode.Ldarga_S || opcode == OperationCode.Starg_S)
{
this.offset += 1;
}
else if (opcode == OperationCode.Ldarg || opcode == OperationCode.Ldarga || opcode == OperationCode.Starg)
{
this.offset += 2;
}
}
private string GetModifier(IParameterDefinition parameter)
{
if (parameter.IsOut && !parameter.IsIn && parameter.IsByReference)
{
return("out");
}
else if (parameter.IsByReference)
{
return("ref");
}
return("in");
}
public virtual void PrintParameterDefinitionModifiers(IParameterDefinition parameterDefinition)
{
Contract.Requires(parameterDefinition != null);
if (parameterDefinition.Index == 0)
{
var meth = parameterDefinition.ContainingSignature as IMethodDefinition;
if (meth != null)
{
if (Utils.FindAttribute(meth.Attributes, SpecialAttribute.Extension) != null)
{
PrintToken(CSharpToken.This);
PrintToken(CSharpToken.Space);
}
}
}
foreach (var attribute in SortAttributes(parameterDefinition.Attributes))
{
if (Utils.GetAttributeType(attribute) == SpecialAttribute.ParamArray)
{
sourceEmitterOutput.Write("params");
}
else
{
this.PrintAttribute(parameterDefinition, attribute, false, null);
}
PrintToken(CSharpToken.Space);
}
if (parameterDefinition.IsOut && !parameterDefinition.IsIn && parameterDefinition.IsByReference)
{
// C# out keyword means [Out] ref (with no [In] allowed)
PrintKeywordOut();
}
else
{
if (parameterDefinition.IsIn)
{
PrintPseudoCustomAttribute(parameterDefinition, "System.Runtime.InteropServices.In", null, false, null);
}
if (parameterDefinition.IsOut)
{
PrintPseudoCustomAttribute(parameterDefinition, "System.Runtime.InteropServices.Out", null, false, null);
}
if (parameterDefinition.IsByReference)
{
PrintKeywordRef();
}
}
}
/// <summary>
/// Translates the parameter list position of the given parameter to an IL parameter index. In other words,
/// it adds 1 to the parameterDefinition.Index value if the containing method has an implicit this parameter.
/// </summary>
private static ushort GetParameterIndex(IParameterDefinition /*?*/ parameterDefinition)
{
if (parameterDefinition == null)
{
return(0);
}
ushort parameterIndex = parameterDefinition.Index;
if (!parameterDefinition.ContainingSignature.IsStatic)
{
parameterIndex++;
}
return(parameterIndex);
}
public MethodParameter(IParameterDefinition parameterDefinition, Bpl.Type ptype) {
this.underlyingParameter = parameterDefinition;
var parameterToken = parameterDefinition.Token();
var typeToken = parameterDefinition.Type.Token();
var parameterName = TranslationHelper.TurnStringIntoValidIdentifier(parameterDefinition.Name.Value);
if (String.IsNullOrWhiteSpace(parameterName)) parameterName = "P" + parameterDefinition.Index.ToString();
this.inParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$in", ptype), true);
if (parameterDefinition.IsByReference) {
this.outParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$out", ptype), false);
} else {
this.outParameterCopy = new Bpl.LocalVariable(parameterToken, new Bpl.TypedIdent(typeToken, parameterName, ptype));
}
}
private static string GetParameterSignature(IParameterDefinition pDefinition)
{
// TODO: if pDefinition.IsByReference
string signatureContainer = null;
if (pDefinition.ContainingSignature is IMethodDefinition)
{
signatureContainer = GetMethodSignature(pDefinition.ContainingSignature as IMethodDefinition);
}
else
{
throw new NotSupportedException();
}
return(signatureContainer + "|" + pDefinition.ToString());
}
private static bool IsParameterSupported(IParameterDefinition parameterDefinition)
{
var parameterType = parameterDefinition.Type;
// special short-circuit for specific marshalling.
if (parameterDefinition.IsMarshalledExplicitly)
{
var unmanagedType = parameterDefinition.MarshallingInformation.UnmanagedType;
switch (unmanagedType)
{
case UnmanagedType.LPWStr:
case UnmanagedType.LPStr:
return(parameterType.IsString() || parameterType.IsStringArray());
case UnmanagedType.LPArray:
if (parameterType.IsBlittable())
{
return(true);
}
if (parameterType.IsStringArray())
{
var elementType = parameterDefinition.MarshallingInformation.ElementType;
if (elementType == UnmanagedType.LPStr || elementType == UnmanagedType.LPWStr)
{
return(true);
}
}
return(false);
}
}
// blittable, delegates and strings -- these last two have special marshalling we take care of
if (parameterType.TypeCode == PrimitiveTypeCode.Boolean || parameterType.IsBlittable() || parameterType.IsDelegate() || parameterType.IsString())
{
return(true);
}
// we also support string[] since it's so common, by converting it to IntPtr[] in a try/finally
if (parameterType.IsStringArray())
{
return(true);
}
// TODO: Support ICustomMarshaler
return(false);
}
private void WriteParameter(IParameterDefinition parameter, ITypeReference containingType, bool extensionMethod, byte?methodNullableContextValue)
{
WriteAttributes(parameter.Attributes, true);
if (extensionMethod)
{
WriteKeyword("this");
}
if (parameter.IsParameterArray)
{
WriteKeyword("params");
}
if (parameter.IsOut && !parameter.IsIn && parameter.IsByReference)
{
WriteKeyword("out");
}
else
{
// For In/Out we should not emit them until we find a scenario that is needs them.
//if (parameter.IsIn)
// WriteFakeAttribute("System.Runtime.InteropServices.In", writeInline: true);
//if (parameter.IsOut)
// WriteFakeAttribute("System.Runtime.InteropServices.Out", writeInline: true);
if (parameter.IsByReference)
{
if (parameter.Attributes.HasIsReadOnlyAttribute())
{
WriteKeyword("in");
}
else
{
WriteKeyword("ref");
}
}
}
WriteTypeName(parameter.Type, containingType, parameter.Attributes, methodNullableContextValue);
WriteIdentifier(parameter.Name);
if (parameter.IsOptional && parameter.HasDefaultValue)
{
WriteSymbol(" = ");
WriteMetadataConstant(parameter.DefaultValue, parameter.Type);
}
}
/// <summary>
/// A parameter definition that is just a new name (and object identity) for an existing parameter. The existing parameter
/// can be recovered via the OriginalParameter property.
/// </summary>
/// <param name="originalParameter">The parameter for which the new parameter provides a new name and new object identity.</param>
/// <param name="name"></param>
/// <param name="containingType"></param>
public SSAParameterDefinition(IParameterDefinition originalParameter, IName name, ITypeDefinition containingType)
{
Contract.Requires(originalParameter != null);
Contract.Requires(name != null);
Contract.Requires(containingType != null);
this.originalParameter = originalParameter;
this.name = name;
if (originalParameter.Type is Dummy)
{
this.type = containingType; //should only happen if the parameter is the this parameter.
}
else
{
this.type = originalParameter.Type;
}
}
private string GetModifier(IParameterDefinition parameter)
{
if (parameter.IsOut && !parameter.IsIn && parameter.IsByReference)
{
return("out");
}
else if (parameter.IsByReference)
{
if (parameter.Attributes.HasIsReadOnlyAttribute())
{
return("in");
}
return("ref");
}
return("<none>");
}
public override void TraverseChildren(IBoundExpression boundExpression)
{
base.TraverseChildren(boundExpression);
ITypeReference type = Dummy.TypeReference;
ILocalDefinition /*?*/ local = boundExpression.Definition as ILocalDefinition;
if (local != null)
{
type = local.Type;
if (local.IsReference)
{
if (local.IsPinned)
{
type = Immutable.PointerType.GetPointerType(type, this.host.InternFactory);
}
else
{
type = Immutable.ManagedPointerType.GetManagedPointerType(type, this.host.InternFactory);
}
}
}
else
{
IParameterDefinition /*?*/ parameter = boundExpression.Definition as IParameterDefinition;
if (parameter != null)
{
type = parameter.Type;
if (parameter.IsByReference)
{
type = Immutable.ManagedPointerType.GetManagedPointerType(type, this.host.InternFactory);
}
}
else
{
IFieldReference /*?*/ field = boundExpression.Definition as IFieldReference;
if (field != null)
{
type = field.Type;
}
}
}
((BoundExpression)boundExpression).Type = type;
}
XElement GetParamElement(XElement member, IParameterDefinition param)
{
Contract.Requires(member != null);
Contract.Ensures(Contract.Result <XElement>() != null);
foreach (var el in member.Elements("param"))
{
if (el.Attribute("name").Value == param.Name.Value)
{
return(el);
}
}
var paramElement = new XElement("param");
paramElement.SetAttributeValue("name", param.Name);
return(paramElement);
}
public MethodParameter(IParameterDefinition parameterDefinition) {
this.underlyingParameter = parameterDefinition;
Bpl.Type ptype = Bpl.Type.Int;
var parameterToken = parameterDefinition.Token();
var typeToken = parameterDefinition.Type.Token();
var parameterName = parameterDefinition.Name.Value;
if (!parameterDefinition.IsOut) {
this.inParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$in", ptype), true);
}
if (parameterDefinition.IsByReference || parameterDefinition.IsOut) {
this.outParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$out", ptype), false);
} else {
this.outParameterCopy = new Bpl.LocalVariable(parameterToken, new Bpl.TypedIdent(typeToken, parameterName, ptype));
}
}
/// <summary>
/// Performs some computation with the given parameter definition.
/// </summary>
public virtual void Visit(IParameterDefinition parameterDefinition)
{
}
private static string GetParameterSignature(IParameterDefinition pDefinition)
{
// TODO: if pDefinition.IsByReference
string signatureContainer = null;
if (pDefinition.ContainingSignature is IMethodDefinition) signatureContainer = GetMethodSignature(pDefinition.ContainingSignature as IMethodDefinition);
else throw new NotSupportedException();
return signatureContainer + "|" + pDefinition.ToString();
}
public void Visit(IParameterDefinition parameterDefinition)
{
this.traverser.Traverse(parameterDefinition);
}
public void VisitReference(IParameterDefinition parameterDefinition)
{
Contract.Assume(false);
}
/// <summary>
/// Puts the specified instruction onto the Microsoft intermediate language (MSIL) stream followed by the index of the given local variable.
/// </summary>
/// <param name="opcode">The Microsoft intermediate language (MSIL) instruction to be put onto the stream.</param>
/// <param name="parameter">A parameter definition.</param>
public void Emit(OperationCode opcode, IParameterDefinition parameter)
{
this.operations.Add(new Operation(opcode, this.offset, this.GetCurrentSequencePoint(), parameter));
this.offset += SizeOfOperationCode(opcode);
if (opcode == OperationCode.Ldarg_S || opcode == OperationCode.Ldarga_S || opcode == OperationCode.Starg_S)
this.offset += 1;
else if (opcode == OperationCode.Ldarg || opcode == OperationCode.Ldarga || opcode == OperationCode.Starg)
this.offset += 2;
}
public void VisitReference(IParameterDefinition parameterDefinition)
{
throw new NotImplementedException();
}
public void AddOriginalParameter(IParameterDefinition parameter)
{
var parameterInfo = new ReplacementParameterInfo();
parameterInfo.Name = parameter.Name.Value;
parameterInfo.IsOut = parameter.IsOut;
parameterInfo.IsRef = parameter.IsByReference;
parameterInfo.Type = parameter.Type;
parameterInfo.Definition = parameter;
}
/// <summary>
/// Performs some computation with the given parameter definition.
/// </summary>
public void VisitReference(IParameterDefinition parameterDefinition)
{
}
public virtual void PrintParameterDefinitionType(IParameterDefinition parameterDefinition) {
Contract.Requires(parameterDefinition != null);
PrintTypeReference(parameterDefinition.Type);
}
protected IParameterDefinition[] GetModuleParameters(bool useParamInfo, ISignature signatureDefinition, int paramCount) {
MethodDefinition/*?*/ moduleMethod = signatureDefinition as MethodDefinition;
int paramIndex = 0;
var parameters = new IParameterDefinition[paramCount];
while (paramIndex < paramCount) {
bool dummyPinned;
var customModifiers = this.GetCustomModifiers(out dummyPinned);
byte currByte = this.SignatureMemoryReader.PeekByte(0);
if (currByte == ElementType.Sentinel) {
this.SignatureMemoryReader.SkipBytes(1);
var requiredParameters = new IParameterDefinition[paramIndex];
for (int i = 0; i < paramIndex; i++) requiredParameters[i] = parameters[i];
return requiredParameters;
}
bool isByReference = false;
ITypeReference/*?*/ typeReference;
if (currByte == ElementType.TypedReference) {
this.SignatureMemoryReader.SkipBytes(1);
typeReference = this.PEFileToObjectModel.PlatformType.SystemTypedReference;
} else {
if (currByte == ElementType.ByReference) {
this.SignatureMemoryReader.SkipBytes(1);
isByReference = true;
}
typeReference = this.GetTypeReference();
}
ParamInfo? paramInfo = useParamInfo ? this.GetParamInfo(paramIndex + 1) : null;
IParameterDefinition moduleParameter;
if (paramInfo.HasValue) {
var paramArrayType = typeReference as IArrayTypeReference;
moduleParameter = new ParameterWithMetadata(this.PEFileToObjectModel, paramIndex, customModifiers, typeReference, moduleMethod, isByReference,
(paramIndex == paramCount - 1) && paramArrayType != null && paramArrayType.IsVector, paramInfo.Value.ParamRowId, paramInfo.Value.ParamName, paramInfo.Value.ParamFlags);
} else
moduleParameter = new ParameterWithoutMetadata(this.PEFileToObjectModel, paramIndex, customModifiers, typeReference, signatureDefinition, isByReference);
parameters[paramIndex++] = moduleParameter;
}
return parameters;
}
public virtual void Visit(IParameterDefinition parameterDefinition)
{
var marshalling = parameterDefinition.MarshallingInformation;
Debug.Assert((marshalling != null || !parameterDefinition.MarshallingDescriptor.IsDefaultOrEmpty) == parameterDefinition.IsMarshalledExplicitly);
this.Visit(parameterDefinition.GetAttributes(Context));
this.Visit(parameterDefinition.CustomModifiers);
IMetadataConstant defaultValue = parameterDefinition.GetDefaultValue(Context);
if (defaultValue != null)
{
this.Visit((IMetadataExpression)defaultValue);
}
if (marshalling != null)
{
// Note, we are not visiting MarshallingDescriptor. It is used only for
// NoPia embedded/local types and VB Dev11 simply copies the bits without
// cracking them.
this.Visit(marshalling);
}
this.Visit(parameterDefinition.GetType(Context));
}
public virtual void PrintParameterDefinitionName(IParameterDefinition parameterDefinition) {
Contract.Requires(parameterDefinition != null);
PrintIdentifier(parameterDefinition.Name);
}
private void WriteParameter(IParameterDefinition parameter, bool extensionMethod)
{
WriteAttributes(parameter.Attributes, true);
if (extensionMethod)
WriteKeyword("this");
if (parameter.IsParameterArray)
WriteKeyword("params");
if (parameter.IsOut && !parameter.IsIn && parameter.IsByReference)
{
WriteKeyword("out");
}
else
{
// For In/Out we should not emit them until we find a scenario that is needs thems.
//if (parameter.IsIn)
// WriteFakeAttribute("System.Runtime.InteropServices.In", writeInline: true);
//if (parameter.IsOut)
// WriteFakeAttribute("System.Runtime.InteropServices.Out", writeInline: true);
if (parameter.IsByReference)
WriteKeyword("ref");
}
WriteTypeName(parameter.Type, isDynamic: IsDynamic(parameter.Attributes));
WriteIdentifier(parameter.Name);
if (parameter.IsOptional && parameter.HasDefaultValue)
{
WriteSymbol("=");
WriteMetadataConstant(parameter.DefaultValue, parameter.Type);
}
}
private static HLParameter CreateParameter(IParameterDefinition pDefinition)
{
HLParameter parameter = new HLParameter();
//parameter.Definition = pDefinition;
parameter.Name = pDefinition.Name.Value;
parameter.Signature = HLDomain.GetParameterSignature(pDefinition);
sParameters[parameter.Signature] = parameter;
//if (pDefinition.ContainingSignature is IMethodDefinition) parameter.MethodContainer = GetOrCreateMethod(pDefinition.ContainingSignature as IMethodDefinition);
//else throw new NotSupportedException();
ITypeReference type = pDefinition.Type;
if (pDefinition.IsByReference) type = MutableModelHelper.GetManagedPointerTypeReference(type, Host.InternFactory, type);
parameter.IsReference = pDefinition.IsByReference;
parameter.Type = GetOrCreateType(type);
return parameter;
}
public virtual void onMetadataElement(IParameterDefinition parameterDefinition) { }
/// <summary>
/// Performs some computation with the given parameter definition.
/// </summary>
public void Visit(IParameterDefinition parameterDefinition)
{
if (parameterDefinition.HasDefaultValue) {
var parameterType = parameterDefinition.Type;
if (parameterType.IsEnum && parameterType.ResolvedType != Dummy.Type) parameterType = parameterType.ResolvedType.UnderlyingType;
if (!TypeHelper.TypesAreEquivalent(parameterDefinition.DefaultValue.Type, parameterType))
this.ReportError(MetadataError.MetadataConstantTypeMismatch, parameterDefinition.DefaultValue, parameterDefinition);
}
if (parameterDefinition.IsMarshalledExplicitly) {
if (parameterDefinition.MarshallingInformation.UnmanagedType == System.Runtime.InteropServices.UnmanagedType.LPArray) {
if (parameterDefinition.MarshallingInformation.ParamIndex != null) {
var index = parameterDefinition.MarshallingInformation.ParamIndex.Value;
if (index >= IteratorHelper.EnumerableCount(parameterDefinition.ContainingSignature.Parameters))
this.ReportError(MetadataError.ParameterIndexIsInvalid, parameterDefinition.MarshallingInformation, parameterDefinition);
if (parameterDefinition.MarshallingInformation.NumberOfElements > 0)
this.ReportError(MetadataError.NumberOfElementsSpecifiedExplicitlyAsWellAsByAParameter, parameterDefinition);
} else {
//The ECMA spec seems to suggest that this check is needed.
//The MSDN documentation claims that these values are ignored when marshalling from the CLR to COM.
//Actual code found in the .NET Framework fail this test. So disable it for now.
//if (parameterDefinition.MarshallingInformation.NumberOfElements == 0 && parameterDefinition.IsOut)
// this.ReportError(MetadataError.ParameterMarshalledArraysMustHaveSizeKnownAtCompileTime, parameterDefinition.MarshallingInformation, parameterDefinition);
}
}
if (parameterDefinition.MarshallingInformation.UnmanagedType == System.Runtime.InteropServices.UnmanagedType.ByValArray) {
this.ReportError(MetadataError.ParameterCannotBeMarshalledAsByValArray, parameterDefinition.MarshallingInformation, parameterDefinition);
}
if (parameterDefinition.MarshallingInformation.UnmanagedType == System.Runtime.InteropServices.UnmanagedType.ByValTStr) {
if (parameterDefinition.MarshallingInformation.NumberOfElements == 0)
this.ReportError(MetadataError.ParameterMarshalledArraysMustHaveSizeKnownAtCompileTime, parameterDefinition.MarshallingInformation, parameterDefinition);
}
}
}
/// <summary>
/// Get mutable copy of a parameter definition of an anonymous delegate. The parameters of anonymous delegate
/// are not visited until the code of a souce method body is visited.
/// </summary>
/// <param name="parameterDefinition"></param>
/// <returns></returns>
private ParameterDefinition GetMutableCopyParamAnonymDeleg(IParameterDefinition parameterDefinition)
{
ParameterDefinition/*?*/ result;
object/*?*/ cachedValue = null;
this.cache.TryGetValue(parameterDefinition, out cachedValue);
result = cachedValue as ParameterDefinition;
if (result != null) return result;
result = new ParameterDefinition();
this.cache.Add(parameterDefinition, result);
this.cache.Add(result, result);
result.Copy(parameterDefinition, this.host.InternFactory);
return result;
}
public static HLParameter GetParameter(IParameterDefinition pDefinition)
{
return sParameters[GetParameterSignature(pDefinition)];
}
/// <summary>
/// Traverses the children of the parameter definition.
/// </summary>
public virtual void TraverseChildren(IParameterDefinition parameterDefinition)
{
Contract.Requires(parameterDefinition != null);
this.Traverse(parameterDefinition.Attributes);
if (this.stopTraversal) return;
if (parameterDefinition.IsModified) {
this.Traverse(parameterDefinition.CustomModifiers);
if (this.stopTraversal) return;
}
if (parameterDefinition.HasDefaultValue) {
this.Traverse(parameterDefinition.DefaultValue);
if (this.stopTraversal) return;
}
if (parameterDefinition.IsMarshalledExplicitly) {
this.Traverse(parameterDefinition.MarshallingInformation);
if (this.stopTraversal) return;
}
this.Traverse(parameterDefinition.Type);
}
//^ ensures this.path.Count == old(this.path.Count);
/// <summary>
/// Performs some computation with the given parameter definition.
/// </summary>
/// <param name="parameterDefinition"></param>
public virtual void Visit(IParameterDefinition parameterDefinition)
{
if (this.stopTraversal) return;
//^ int oldCount = this.path.Count;
this.path.Push(parameterDefinition);
this.Visit(parameterDefinition.Attributes);
if (parameterDefinition.IsModified)
this.Visit(parameterDefinition.CustomModifiers);
if (parameterDefinition.HasDefaultValue)
this.Visit((IMetadataExpression)parameterDefinition.DefaultValue);
if (parameterDefinition.IsMarshalledExplicitly)
this.Visit(parameterDefinition.MarshallingInformation);
this.Visit(parameterDefinition.Type);
//^ 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 override void TraverseChildren(IParameterDefinition parameterDefinition)
{ MethodEnter(parameterDefinition);
base.TraverseChildren(parameterDefinition);
MethodExit(); }
/// <summary>
/// Traverses the parameter definition.
/// </summary>
public void Traverse(IParameterDefinition parameterDefinition)
{
Contract.Requires(parameterDefinition != null);
if (!this.objectsThatHaveAlreadyBeenTraversed.Add(parameterDefinition)) return;
if (this.preorderVisitor != null) this.preorderVisitor.Visit(parameterDefinition);
if (this.stopTraversal) return;
this.TraverseChildren(parameterDefinition);
if (this.stopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(parameterDefinition);
}
private void LoadParameter(IParameterDefinition parameter) {
TranslatedExpressions.Push(Bpl.Expr.Ident(this.sink.FindParameterVariable(parameter, this.contractContext)));
return;
}
