public override void RewriteChildren(AddressableExpression addressableExpression) {
BoundField/*?*/ boundField;
if (this.fieldForCapturedLocalOrParameter.TryGetValue(addressableExpression.Definition, out boundField)) {
addressableExpression.Instance = new ThisReference();
addressableExpression.Definition = iteratorClosure.GetReferenceOfFieldUsedByPeers(boundField.Field);
addressableExpression.Type = boundField.Type;
return;
}
base.RewriteChildren(addressableExpression);
}
private Expression ParseArrayElementAddres(IOperation currentOperation)
{
AddressOf result = new AddressOf();
result.ObjectControlsMutability = this.sawReadonly;
AddressableExpression addressableExpression = new AddressableExpression();
result.Expression = addressableExpression;
ArrayIndexer indexer = this.ParseArrayIndexer(currentOperation);
addressableExpression.Definition = indexer;
addressableExpression.Instance = indexer.IndexedObject;
this.sawReadonly = false;
return result;
}
private Expression ParseAddressOf(IOperation currentOperation)
{
AddressableExpression addressableExpression = new AddressableExpression();
if (currentOperation.Value == null) {
Debug.Assert(currentOperation.OperationCode == OperationCode.Ldarg || currentOperation.OperationCode == OperationCode.Ldarga_S);
addressableExpression.Definition = new ThisReference();
} else
addressableExpression.Definition = currentOperation.Value;
if (currentOperation.OperationCode == OperationCode.Ldflda || currentOperation.OperationCode == OperationCode.Ldvirtftn)
addressableExpression.Instance = this.PopOperandStack();
if (currentOperation.OperationCode == OperationCode.Ldloca || currentOperation.OperationCode == OperationCode.Ldloca_S) {
var local = this.GetLocalWithSourceName((ILocalDefinition)currentOperation.Value);
addressableExpression.Definition = local;
this.numberOfReferences[local] = this.numberOfReferences.ContainsKey(local) ? this.numberOfReferences[local] + 1 : 1;
//Treat this as an assignment as well, so that the local does not get deleted because it contains a constant and has only one assignment to it.
this.numberOfAssignments[local] = this.numberOfAssignments.ContainsKey(local) ? this.numberOfAssignments[local] + 1 : 1;
}
return new AddressOf() { Expression = addressableExpression };
}
/// <summary>
/// Rewrites the children of the given addressable expression.
/// </summary>
public override void RewriteChildren(AddressableExpression addressableExpression) {
IFieldReference closureField;
var map = this.isInsideAnonymousMethod ? this.fieldReferencesForUseInsideAnonymousMethods : this.fieldReferencesForUseInsideThisMethod;
if (map.TryGetValue(addressableExpression.Definition, out closureField)) {
addressableExpression.Instance = this.GetClosureObjectInstanceContaining(closureField);
addressableExpression.Definition = closureField;
addressableExpression.Type = closureField.Type;
return;
}
base.RewriteChildren(addressableExpression);
}
private Expression ParseArrayElementAddres(IOperation currentOperation, ITypeReference elementType, bool treatArrayAsSingleDimensioned = false) {
Contract.Requires(currentOperation != null);
Contract.Requires(elementType != null);
AddressOf result = new AddressOf();
result.ObjectControlsMutability = this.sawReadonly;
AddressableExpression addressableExpression = new AddressableExpression();
result.Expression = addressableExpression;
ArrayIndexer indexer = this.ParseArrayIndexer(currentOperation, elementType, treatArrayAsSingleDimensioned);
addressableExpression.Definition = indexer;
addressableExpression.Instance = indexer.IndexedObject;
addressableExpression.Type = elementType;
this.sawReadonly = false;
return result;
}
private Expression ParseAddressOf(Instruction instruction) {
Contract.Requires(instruction != null);
var currentOperation = instruction.Operation;
AddressableExpression addressableExpression = new AddressableExpression();
if (currentOperation.Value == null) {
Contract.Assume(currentOperation.OperationCode == OperationCode.Ldarga || currentOperation.OperationCode == OperationCode.Ldarga_S);
var thisType = this.cdfg.MethodBody.MethodDefinition.ContainingTypeDefinition;
addressableExpression.Definition = new ThisReference() { Type = thisType };
addressableExpression.Type = thisType;
} else {
var definition = currentOperation.Value;
Contract.Assume(definition is ILocalDefinition || definition is IParameterDefinition ||
definition is IFieldReference || definition is IMethodReference || definition is IExpression);
addressableExpression.Definition = definition;
addressableExpression.Type = GetTypeFrom(definition);
}
if (currentOperation.OperationCode == OperationCode.Ldflda || currentOperation.OperationCode == OperationCode.Ldvirtftn)
addressableExpression.Instance = this.PopOperandStack();
if (currentOperation.OperationCode == OperationCode.Ldloca || currentOperation.OperationCode == OperationCode.Ldloca_S) {
var local = this.GetLocalWithSourceName((ILocalDefinition)currentOperation.Value);
addressableExpression.Definition = local;
this.numberOfReferencesToLocal[local] = this.numberOfReferencesToLocal.ContainsKey(local) ? this.numberOfReferencesToLocal[local] + 1 : 1;
//Treat this as an assignment as well, so that the local does not get deleted because it contains a constant and has only one assignment to it.
this.numberOfAssignmentsToLocal[local] = this.numberOfAssignmentsToLocal.ContainsKey(local) ? this.numberOfAssignmentsToLocal[local] + 1 : 1;
if (this.instructionsThatMakeALastUseOfALocalVersion.Contains(instruction)) {
this.instructionsThatMakeALastUseOfALocalVersion.Remove(instruction);
this.bindingsThatMakeALastUseOfALocalVersion.Add(addressableExpression);
}
}
return new AddressOf() { Expression = addressableExpression };
}
/// <summary>
/// Visits the specified addressable expression.
/// </summary>
/// <param name="addressableExpression">The addressable expression.</param>
/// <returns></returns>
protected virtual IAddressableExpression DeepCopy(AddressableExpression addressableExpression)
{
object def = addressableExpression.Definition;
ILocalDefinition/*?*/ loc = def as ILocalDefinition;
if (loc != null)
addressableExpression.Definition = this.GetMutableCopyIfItExists(loc);
else {
IParameterDefinition/*?*/ par = def as IParameterDefinition;
if (par != null)
addressableExpression.Definition = this.GetMutableCopyIfItExists(par);
else {
IFieldReference/*?*/ field = def as IFieldReference;
if (field != null)
addressableExpression.Definition = this.Substitute(field);
else {
IArrayIndexer/*?*/ indexer = def as IArrayIndexer;
if (indexer != null)
addressableExpression.Definition = this.Substitute(indexer);
else {
IAddressDereference/*?*/ adr = def as IAddressDereference;
if (adr != null)
addressableExpression.Definition = this.Substitute(adr);
else {
IMethodReference/*?*/ meth = def as IMethodReference;
if (meth != null)
addressableExpression.Definition = this.Substitute(meth);
else {
IThisReference thisRef = (IThisReference)def;
addressableExpression.Definition = this.Substitute(thisRef);
}
}
}
}
}
}
if (addressableExpression.Instance != null)
addressableExpression.Instance = this.Substitute(addressableExpression.Instance);
addressableExpression.Type = this.Substitute(addressableExpression.Type);
return addressableExpression;
}
public override void RewriteChildren(AddressableExpression addressableExpression) {
if (addressableExpression.Definition == this.local) {
addressableExpression.Definition = this.expressionToSubstituteForLocal;
this.numberOfAssignmentsToLocal[this.local]--;
this.replacementHappened = true;
return;
}
base.RewriteChildren(addressableExpression);
}
/// <summary>
/// Visits the specified addressable expression.
/// </summary>
/// <param name="addressableExpression">The addressable expression.</param>
public override void Visit(IAddressableExpression addressableExpression)
{
AddressableExpression mutableAddressableExpression = new AddressableExpression(addressableExpression);
this.resultExpression = this.myCodeCopier.DeepCopy(mutableAddressableExpression);
}
public override void RewriteChildren(AddressableExpression addressableExpression) {
IExpression capturedThing;
var field = addressableExpression.Definition as IFieldReference;
if (field != null) {
var k = field.InternedKey;
var spec = field as ISpecializedFieldReference;
if (spec != null) k = spec.UnspecializedVersion.InternedKey;
if (this.capturedThings.TryGetValue(k, out capturedThing)) {
var be = capturedThing as IBoundExpression;
if (be == null) {
System.Diagnostics.Debug.Assert(false);
}
addressableExpression.Definition = be.Definition;
addressableExpression.Instance = be.Instance;
return;
}
}
base.RewriteChildren(addressableExpression);
}
public override IAddressableExpression Visit(AddressableExpression addressableExpression)
{
var closureField = addressableExpression.Definition as IFieldReference;
if (closureField != null) {
var unspecializedClosureField = UnspecializedMethods.UnspecializedFieldReference(closureField);
IBoundExpression binding = null;
if (this.capturedBinding.TryGetValue(unspecializedClosureField.InternedKey, out binding)) {
addressableExpression.Definition = binding.Definition;
addressableExpression.Instance = binding.Instance;
return addressableExpression;
}
}
var parameter = addressableExpression.Definition as IParameterDefinition;
if (parameter != null) {
IParameterDefinition parToSubstitute;
if (this.parameterMap.TryGetValue(parameter, out parToSubstitute)) {
addressableExpression.Definition = parToSubstitute;
return addressableExpression;
}
}
return base.Visit(addressableExpression);
}
/// <summary>
/// If the <paramref name="addressableExpression"/> represents a parameter of the target method,
/// it is replaced with the equivalent parameter of the source method.
/// </summary>
/// <param name="addressableExpression">The addressable expression.</param>
public override void RewriteChildren(AddressableExpression addressableExpression) {
var/*?*/ par = addressableExpression.Definition as IParameterDefinition;
if (par != null && par.ContainingSignature == this.targetMethod) {
addressableExpression.Definition = this.parameters[par.Index];
if (addressableExpression.Instance != null) {
addressableExpression.Instance = this.Rewrite(addressableExpression.Instance);
}
addressableExpression.Type = this.Rewrite(addressableExpression.Type);
return;
} else {
base.RewriteChildren(addressableExpression);
}
}
/// <summary>
/// Visits the specified addressable expression.
/// </summary>
/// <param name="addressableExpression">The addressable expression.</param>
/// <returns></returns>
public virtual IAddressableExpression Visit(AddressableExpression addressableExpression)
{
object def = addressableExpression.Definition;
ILocalDefinition/*?*/ loc = def as ILocalDefinition;
if (loc != null)
addressableExpression.Definition = this.VisitReferenceTo(loc);
else {
IParameterDefinition/*?*/ par = def as IParameterDefinition;
if (par != null)
addressableExpression.Definition = this.VisitReferenceTo(par);
else {
IFieldReference/*?*/ field = def as IFieldReference;
if (field != null)
addressableExpression.Definition = this.Visit(field);
else {
IArrayIndexer/*?*/ indexer = def as IArrayIndexer;
if (indexer != null)
addressableExpression.Definition = this.Visit(indexer);
else {
IAddressDereference/*?*/ adr = def as IAddressDereference;
if (adr != null)
addressableExpression.Definition = this.Visit(adr);
else {
IMethodReference/*?*/ meth = def as IMethodReference;
if (meth != null)
addressableExpression.Definition = this.Visit(meth);
else {
IThisReference thisRef = (IThisReference)def;
addressableExpression.Definition = this.Visit(thisRef);
}
}
}
}
}
}
if (addressableExpression.Instance != null)
addressableExpression.Instance = this.Visit(addressableExpression.Instance);
addressableExpression.Type = this.Visit(addressableExpression.Type);
return addressableExpression;
}
/// <summary>
/// Rewrites the children of the given addressable expression.
/// </summary>
/// <param name="addressableExpression"></param>
public virtual void RewriteChildren(AddressableExpression addressableExpression)
{
this.RewriteChildren((Expression)addressableExpression);
var local = addressableExpression.Definition as ILocalDefinition;
if (local != null)
addressableExpression.Definition = this.RewriteReference(local);
else {
var parameter = addressableExpression.Definition as IParameterDefinition;
if (parameter != null)
addressableExpression.Definition = this.RewriteReference(parameter);
else {
var fieldReference = addressableExpression.Definition as IFieldReference;
if (fieldReference != null)
addressableExpression.Definition = this.Rewrite(fieldReference);
else {
var arrayIndexer = addressableExpression.Definition as IArrayIndexer;
if (arrayIndexer != null) {
addressableExpression.Definition = this.Rewrite(arrayIndexer);
return; //do not rewrite Instance again
} else {
var addressDereference = addressableExpression.Definition as IAddressDereference;
if (addressDereference != null)
addressableExpression.Definition = this.Rewrite(addressDereference);
else {
var methodReference = addressableExpression.Definition as IMethodReference;
if (methodReference != null)
addressableExpression.Definition = this.Rewrite(methodReference);
else {
var thisReference = (IThisReference)addressableExpression.Definition;
addressableExpression.Definition = this.Rewrite(thisReference);
}
}
}
}
}
}
if (addressableExpression.Instance != null)
addressableExpression.Instance = this.Rewrite(addressableExpression.Instance);
}
/// <summary>
/// Visits the specified addressable expression.
/// </summary>
/// <param name="addressableExpression">The addressable expression.</param>
public override void Visit(IAddressableExpression addressableExpression)
{
AddressableExpression mutableAddressableExpression = addressableExpression as AddressableExpression;
if (alwaysMakeACopy || mutableAddressableExpression == null) mutableAddressableExpression = new AddressableExpression(addressableExpression);
this.resultExpression = this.myCodeMutator.Visit(mutableAddressableExpression);
}
/// <summary>
/// Visits the specified addressable expression.
/// </summary>
/// <param name="addressableExpression">The addressable expression.</param>
/// <returns></returns>
public virtual IAddressableExpression Visit(IAddressableExpression addressableExpression)
{
AddressableExpression mutableAddressableExpression = addressableExpression as AddressableExpression;
if (!this.copyOnlyIfNotAlreadyMutable || mutableAddressableExpression == null)
mutableAddressableExpression = new AddressableExpression(addressableExpression);
return Visit(mutableAddressableExpression);
}
