public void LeaveInvariant(HashSet <TKey> keys)
{
#if DEBUG
var liveKeys = GetLiveKeys();
ContractHelpers.Assert(keys.IsSubsetOf(liveKeys));
#endif
}
/// <summary>
/// Tells if a particular instruction is dominated by another instruction,
/// that is, if control cannot flow to the instruction unless it first flowed
/// through the dominator instruction.
/// </summary>
/// <param name="instruction">
/// An instruction that might be dominated by <paramref name="dominator"/>.
/// </param>
/// <param name="dominator">
/// An instruction that might dominate <paramref name="instruction"/>.
/// </param>
/// <returns>
/// <c>true</c> if <paramref name="instruction"/> is strictly dominated by
/// <paramref name="dominator"/> or <paramref name="instruction"/> equals
/// <paramref name="dominator"/>; otherwise, <c>false</c>.
/// </returns>
public bool IsDominatedBy(NamedInstruction instruction, NamedInstruction dominator)
{
var graph = instruction.Block.Graph;
ContractHelpers.Assert(graph == dominator.Block.Graph);
return(IsDominatedBy(instruction, dominator, graph));
}
public override CompositeActivator RewriteActivator(
TypeInfo partType,
CompositeActivator activatorBody,
IDictionary <string, object> partMetadata,
IEnumerable <CompositionDependency> dependencies)
{
if (!ContractHelpers.IsShared(partMetadata))
{
return(activatorBody);
}
object sharingBoundaryMetadata;
if (!partMetadata.TryGetValue(SharingBoundaryPartMetadataName, out sharingBoundaryMetadata))
{
sharingBoundaryMetadata = null;
}
var sharingBoundary = (string)sharingBoundaryMetadata;
var sharingKey = LifetimeContext.AllocateSharingId();
return((c, o) =>
{
var scope = c.FindContextWithin(sharingBoundary);
if (object.ReferenceEquals(scope, c))
{
return scope.GetOrCreate(sharingKey, o, activatorBody);
}
else
{
return CompositionOperation.Run(scope, (c1, o1) => c1.GetOrCreate(sharingKey, o1, activatorBody));
}
});
}
/// <summary>
/// Removes the instruction with a particular tag from
/// this basic block. Returns a new basic block in a new
/// control-flow graph.
/// </summary>
/// <param name="tag">The tag of the instruction to remove.</param>
/// <returns>A new basic block in a new control-flow graph.</returns>
public BasicBlock RemoveInstruction(ValueTag tag)
{
ContractHelpers.Assert(
Graph.GetValueParent(tag).Tag == this.Tag,
"Basic block does not define the instruction being removed.");
return(Graph.RemoveInstruction(tag).GetBasicBlock(this.Tag));
}
/// <summary>
/// Gets the call instruction prototype for a particular callee.
/// </summary>
/// <param name="callee">The method to call.</param>
/// <param name="lookup">The method lookup strategy for the call.</param>
/// <returns>A call instruction prototype.</returns>
public static CallPrototype Create(IMethod callee, MethodLookup lookup)
{
ContractHelpers.Assert(
lookup == MethodLookup.Static || !callee.IsStatic,
"A static callee method cannot be resolved via virtual lookup.");
return(instanceCache.Intern(new CallPrototype(callee, lookup)));
}
private IEnumerable <CompositionDependency> GetPartActivatorDependencies(DependencyAccessor definitionAccessor)
{
var partTypeAsType = _partType.AsType();
if (_constructor == null)
{
foreach (var c in _partType.DeclaredConstructors.Where(ci => ci.IsPublic && !(ci.IsStatic)))
{
if (_attributeContext.GetDeclaredAttribute <ImportingConstructorAttribute>(partTypeAsType, c) != null)
{
if (_constructor != null)
{
string message = SR.Format(SR.DiscoveredPart_MultipleImportingConstructorsFound, _partType);
throw new CompositionFailedException(message);
}
_constructor = c;
}
}
if (_constructor == null && _partType.IsGenericType)
{
_constructor = GetConstructorInfoFromGenericType(_partType);
}
if (_constructor == null)
{
_constructor = _partType.DeclaredConstructors
.FirstOrDefault(ci => ci.IsPublic && !(ci.IsStatic || ci.GetParameters().Any()));
}
if (_constructor == null)
{
string message = SR.Format(SR.DiscoveredPart_NoImportingConstructorsFound, _partType);
throw new CompositionFailedException(message);
}
}
var cps = _constructor.GetParameters();
for (var i = 0; i < cps.Length; ++i)
{
var pi = cps[i];
var site = new ParameterImportSite(pi);
var importInfo = ContractHelpers.GetImportInfo(pi.ParameterType, _attributeContext.GetDeclaredAttributes(partTypeAsType, pi), site);
if (!importInfo.AllowDefault)
{
yield return(definitionAccessor.ResolveRequiredDependency(site, importInfo.Contract, true));
}
else
{
CompositionDependency optional;
if (definitionAccessor.TryResolveOptionalDependency(site, importInfo.Contract, true, out optional))
{
yield return(optional);
}
}
}
}
/// <summary>
/// Gets the constrained call instruction prototype for a particular callee.
/// </summary>
/// <param name="callee">The method to call.</param>
/// <returns>A constrained call instruction prototype.</returns>
public static ConstrainedCallPrototype Create(IMethod callee)
{
ContractHelpers.Assert(
!callee.IsStatic,
"Constrained calls cannot call static methods.");
return(instanceCache.Intern(new ConstrainedCallPrototype(callee)));
}
/// <summary>
/// Creates an integer value from the given integer and an integer spec.
/// </summary>
public IntegerConstant(BigInteger value, IntegerSpec spec)
{
ContractHelpers.Assert(spec != null);
this.Value = value;
this.Spec = spec;
}
/// <summary>
/// Reads out an integer spec attribute as an integer spec.
/// </summary>
/// <param name="attribute">The integer spec attribute to read.</param>
/// <returns>The integer spec described by the attribute.</returns>
public static IntegerSpec Read(IntrinsicAttribute attribute)
{
ContractHelpers.Assert(attribute.Name == AttributeName);
ContractHelpers.Assert(attribute.Arguments.Count == 2);
return(new IntegerSpec(
((IntegerConstant)attribute.Arguments[0]).ToInt32(),
((IntegerConstant)attribute.Arguments[1]).ToBoolean()));
}
/// <summary>
/// Adds a generic parameter to this generic member.
/// </summary>
/// <param name="genericParameter">The generic parameter to add.</param>
public void AddGenericParameter(IGenericParameter genericParameter)
{
ContractHelpers.Assert(
object.Equals(this, genericParameter.ParentMember),
"Generic parameters can only be added to their declaring member.");
genericParamList.Add(genericParameter);
}
/// <summary>
/// Casts this integer value to match the given spec.
/// </summary>
public IntegerConstant Cast(IntegerSpec newSpec)
{
var result = new IntegerConstant(newSpec.Cast(Value, Spec), newSpec);
ContractHelpers.Assert(result.Spec.Equals(newSpec));
AssertIsValid(result);
return(result);
}
/// <summary>
/// "Normalizes" the given value, by casting it to this integer spec,
/// from this integer spec. The result of this operation is always
/// representible, even if the input value is not.
/// </summary>
public BigInteger Normalize(BigInteger value)
{
var result = Cast(value, this);
AssertIsRepresentible(result);
ContractHelpers.Assert(!IsRepresentible(value) || value.Equals(result));
return(result);
}
/// <summary>
/// Gets the new-object instruction prototype for a particular constructor.
/// </summary>
/// <param name="constructor">The constructor to initialize objects with.</param>
/// <returns>A new-object instruction prototype.</returns>
public static NewObjectPrototype Create(IMethod constructor)
{
ContractHelpers.Assert(
constructor.IsConstructor && !constructor.IsStatic,
"A new-object instruction prototype's constructor method " +
"must be an instance constructor.");
return(instanceCache.Intern(new NewObjectPrototype(constructor)));
}
/// <summary>
/// Adds a nested type to this type.
/// </summary>
/// <param name="nestedType">The nested type to add.</param>
public void AddNestedType(IType nestedType)
{
ContractHelpers.Assert(
nestedType.Parent.IsType,
"Cannot add a non-nested type as a nested type.");
ContractHelpers.Assert(
object.Equals(this, nestedType.Parent.Type),
"A nested type can only be added to its defining type.");
nestedTypeList.Add(nestedType);
}
static void AssumeInvariantTrue()
{
foreach (Host h in new ArrayList())
{
Contract.Assume(h != null);
ContractHelpers.AssumeInvariant(h);
Contract.Assert(h.Name != null);
}
}
internal BasicBlock UpdateBasicBlockParameters(
BasicBlockTag tag,
ImmutableList <BlockParameter> parameters)
{
AssertContainsBasicBlock(tag);
var oldBlock = blocks[tag];
var newData = new BasicBlockData(
parameters,
oldBlock.InstructionTags,
oldBlock.Flow);
var oldData = blocks[tag];
var oldParams = oldData.Parameters;
var newGraph = new FlowGraph(this, new BasicBlockParametersUpdate(tag));
var paramTypeBuilder = newGraph.blockParamTypes.ToBuilder();
var valueParentBuilder = newGraph.valueParents.ToBuilder();
// Remove the basic block's parameters from the value parent
// and parameter type dictionaries.
int oldParamCount = oldParams.Count;
for (int i = 0; i < oldParamCount; i++)
{
paramTypeBuilder.Remove(oldParams[i].Tag);
valueParentBuilder.Remove(oldParams[i].Tag);
}
// Add the new basic block parameters to the value parent and
// parameter type dictionaries.
int newParamCount = parameters.Count;
for (int i = 0; i < newParamCount; i++)
{
var item = parameters[i];
ContractHelpers.Assert(
!valueParentBuilder.ContainsKey(item.Tag),
"Value tag '" + item.Tag.Name + "' cannot appear twice in the same control-flow graph.");
paramTypeBuilder.Add(item.Tag, item.Type);
valueParentBuilder.Add(item.Tag, tag);
}
newGraph.blockParamTypes = paramTypeBuilder.ToImmutable();
newGraph.valueParents = valueParentBuilder.ToImmutable();
newGraph.blocks = newGraph.blocks.SetItem(tag, newData);
return(new BasicBlock(newGraph, tag, newData));
}
/// <inheritdoc/>
public override BlockFlow WithInstructions(IReadOnlyList <Instruction> instructions)
{
ContractHelpers.Assert(instructions.Count == 1, "Switch flow takes exactly one instruction.");
var newSwitchValue = instructions[0];
if (object.ReferenceEquals(newSwitchValue, SwitchValue))
{
return(this);
}
else
{
return(new SwitchFlow(newSwitchValue, Cases, DefaultBranch));
}
}
/// <inheritdoc/>
public override BlockFlow WithInstructions(IReadOnlyList <Instruction> instructions)
{
ContractHelpers.Assert(instructions.Count == 1, "Try flow takes exactly one instruction.");
var insn = instructions[0];
if (insn == Instruction)
{
return(this);
}
else
{
return(new TryFlow(insn, SuccessBranch, ExceptionBranch));
}
}
/// <inheritdoc/>
public override BlockFlow WithInstructions(IReadOnlyList <Instruction> instructions)
{
ContractHelpers.Assert(instructions.Count == 1, "Return flow takes exactly one instruction.");
var newReturnValue = instructions[0];
if (object.ReferenceEquals(newReturnValue, ReturnValue))
{
return(this);
}
else
{
return(new ReturnFlow(newReturnValue));
}
}
/// <inheritdoc/>
public override BlockFlow WithBranches(IReadOnlyList <Branch> branches)
{
ContractHelpers.Assert(branches.Count == 1, "Jump flow takes exactly one branch.");
var newBranch = branches[0];
if (object.ReferenceEquals(newBranch, Branch))
{
return(this);
}
else
{
return(new JumpFlow(newBranch));
}
}
/// <inheritdoc/>
public override BlockFlow WithBranches(IReadOnlyList <Branch> branches)
{
ContractHelpers.Assert(branches.Count == 2, "Try flow takes exactly two branches.");
var success = branches[0];
var exn = branches[1];
if (success == SuccessBranch && exn == ExceptionBranch)
{
return(this);
}
else
{
return(new TryFlow(Instruction, success, exn));
}
}
/// <summary>
/// Cleans up all buckets allocated to a particular concurrency
/// domain.
/// </summary>
/// <param name="concurrencyDomain">
/// The concurrency domain whose buckets are to be cleaned.
/// </param>
/// <remarks>
/// This method is thread-safe within a single concurrency domain.
/// </remarks>
private void Cleanup(int concurrencyDomain)
{
for (int i = concurrencyDomain; i < buckets.Length; i += MaxConcurrency)
{
ContractHelpers.Assert(GetConcurrencyDomain(i) == concurrencyDomain);
var bucket = buckets[i];
bool wasEmpty = bucket.IsEmpty;
bucket.Cleanup();
if (!wasEmpty && bucket.IsEmpty)
{
Interlocked.Decrement(ref initializedBucketCount);
}
buckets[i] = bucket;
}
}
/// <summary>
/// Casts the given unsigned integer to match this spec.
/// </summary>
private BigInteger CastUnsigned(BigInteger value)
{
// We're dealing with a positive integer, so first, we'll make
// sure it fits in the number of bits we have.
ContractHelpers.Assert(value.Sign >= 0);
var remainder = BigInteger.Remainder(value, UnsignedModulus);
if (remainder.CompareTo(MaxValue) > 0)
{
// We're dealing with two's complement here.
return(BigInteger.Subtract(BigInteger.Remainder(remainder, Modulus), Modulus));
}
else
{
// Unsigned number. Just return the remainder.
return(remainder);
}
}
private static void SatisfyImportsInternal(this CompositionContext exportProvider, object objectWithLooseImports, AttributedModelProvider conventions)
{
if (exportProvider == null)
{
throw new ArgumentNullException(nameof(exportProvider));
}
if (objectWithLooseImports == null)
{
throw new ArgumentNullException(nameof(objectWithLooseImports));
}
if (conventions == null)
{
throw new ArgumentNullException(nameof(conventions));
}
var objType = objectWithLooseImports.GetType();
foreach (var pi in objType.GetRuntimeProperties())
{
ImportInfo importInfo;
var site = new PropertyImportSite(pi);
if (ContractHelpers.TryGetExplicitImportInfo(pi.PropertyType, conventions.GetDeclaredAttributes(pi.DeclaringType, pi), site, out importInfo))
{
object value;
if (exportProvider.TryGetExport(importInfo.Contract, out value))
{
pi.SetValue(objectWithLooseImports, value);
}
else if (!importInfo.AllowDefault)
{
throw new CompositionFailedException(SR.Format(
SR.CompositionContextExtensions_MissingDependency, pi.Name, objectWithLooseImports));
}
}
}
var importsSatisfiedMethods = objectWithLooseImports.GetType().GetRuntimeMethods().Where(m =>
m.CustomAttributes.Any(ca => ca.AttributeType == typeof(OnImportsSatisfiedAttribute)));
foreach (var ois in importsSatisfiedMethods)
{
ois.Invoke(objectWithLooseImports, null);
}
}
/// <summary>
/// Creates an integer size from the given number of bits,
/// and signedness.
/// </summary>
public IntegerSpec(int size, bool isSigned)
{
this.Size = size;
this.IsSigned = isSigned;
ContractHelpers.Assert(size > 0);
this.UnsignedModulus = BigInteger.Pow(new BigInteger((int)2), size);
this.Modulus = BigInteger.Pow(new BigInteger((int)2), DataSize);
this.MaxValue = BigInteger.Subtract(Modulus, BigInteger.One);
if (isSigned)
{
this.MinValue = BigInteger.Negate(Modulus);
}
else
{
this.MinValue = BigInteger.Zero;
}
}
/// <inheritdoc/>
public override BlockFlow WithBranches(IReadOnlyList <Branch> branches)
{
int branchCount = branches.Count;
int caseCount = Cases.Count;
ContractHelpers.Assert(
branchCount == caseCount + 1,
"Got '" + branchCount +
"' branches when re-creating a switch statement, but expected '" +
(caseCount + 1) + "'.");
var newCases = new SwitchCase[caseCount];
for (int i = 0; i < caseCount; i++)
{
newCases[i] = new SwitchCase(Cases[i].Values, branches[i]);
}
return(new SwitchFlow(
SwitchValue,
newCases,
branches[caseCount]));
}
/// <summary>
/// Gets or creates a new-delegate instruction prototype.
/// </summary>
/// <param name="delegateType">
/// The type of delegate produced by instances of the prototype.
/// </param>
/// <param name="callee">
/// The method that is invoked when the delegates produced by instances
/// of the prototype are called.
/// </param>
/// <param name="hasThisArgument">
/// Tells if a 'this' argument is included in the delegate.
/// </param>
/// <param name="lookup">
/// The method lookup strategy for the prototype.
/// </param>
/// <returns>A new-delegate instruction prototype.</returns>
public static NewDelegatePrototype Create(
IType delegateType,
IMethod callee,
bool hasThisArgument,
MethodLookup lookup)
{
if (hasThisArgument)
{
ContractHelpers.Assert(
!callee.IsStatic || callee.Parameters.Count >= 1,
"A callee that is provided a 'this' argument must " +
"be an instance method or take at least one parameter.");
}
ContractHelpers.Assert(
lookup == MethodLookup.Static || !callee.IsStatic,
"A static callee method cannot be resolved via virtual lookup.");
return(instanceCache.Intern(
new NewDelegatePrototype(
delegateType,
callee,
hasThisArgument,
lookup)));
}
/// <inheritdoc/>
public override BlockFlow WithBranches(IReadOnlyList <Branch> branches)
{
ContractHelpers.Assert(branches.Count == 0, "Unreachable flow does not take any branches.");
return(this);
}
/// <inheritdoc/>
public override BlockFlow WithInstructions(IReadOnlyList <Instruction> instructions)
{
ContractHelpers.Assert(instructions.Count == 0, "Unreachable flow does not take any instructions.");
return(this);
}
/// <summary>
/// Gets the 'this' argument in an instruction that conforms to
/// this prototype.
/// </summary>
/// <param name="instruction">
/// An instruction that conforms to this prototype.
/// </param>
/// <returns>The 'this' argument.</returns>
public ValueTag GetThisArgument(Instruction instruction)
{
AssertIsPrototypeOf(instruction);
ContractHelpers.Assert(HasThisArgument);
return(instruction.Arguments[0]);
}
