public ExtractorVisitor(ContractNodes /*!*/ contractNodes, AssemblyNode ultimateTargetAssembly, AssemblyNode realAssembly, bool verbose, bool fSharp) { Contract.Requires(contractNodes != null); Contract.Requires(realAssembly != null); this.contractNodes = contractNodes; this.verbose = verbose; this.fSharp = fSharp; this.visibility = new VisibilityHelper(); this.errorFound = false; this.extractionFinalizer = new ExtractionFinalizer(contractNodes); this.ultimateTargetAssembly = ultimateTargetAssembly; this.realAssembly = realAssembly; this.contractNodes.ErrorFound += delegate(CompilerError error) { // Commented out because the ErrorFound event already had a handler that was printing out a message // and so error messages were getting printed out twice //if (!error.IsWarning || warningLevel > 0) { // Console.WriteLine(error.ToString()); //} errorFound |= !error.IsWarning; }; this.TaskType = new Cache<TypeNode>(() => HelperMethods.FindType(realAssembly, Identifier.For("System.Threading.Tasks"), Identifier.For("Task"))); this.GenericTaskType = new Cache<TypeNode>(() => HelperMethods.FindType(realAssembly, Identifier.For("System.Threading.Tasks"), Identifier.For("Task" + TargetPlatform.GenericTypeNamesMangleChar + "1"))); }
public ClousotExtractor(ContractNodes contractNodes, AssemblyNode ultimateTargetAssembly, AssemblyNode realAssembly, Action<System.CodeDom.Compiler.CompilerError> errorHandler) : base(contractNodes, ultimateTargetAssembly, realAssembly) { Contract.Requires(contractNodes != null); Contract.Requires(realAssembly != null); }
public CurrentState(AssemblyNode assembly) { this.Assembly = assembly; this.Type = null; this.Method = null; this.assemblySuppressed = null; this.typeSuppressed = null; this.methodSuppressed = null; }
public static Method FindShadow(this Method method, AssemblyNode shadowAssembly) { var shadowParent = method.DeclaringType.FindShadow(shadowAssembly); if (shadowParent == null) return null; return shadowParent.FindShadow(method); }
public virtual void Add(AssemblyNode assembly) { if (assembly == null) throw new ArgumentNullException("assembly"); string name = assembly.StrongName; assembly.AssemblyReferenceResolution += new Module.AssemblyReferenceResolver(ResolveReference); assembly.AssemblyReferenceResolutionAfterProbingFailed += new Module.AssemblyReferenceResolver(UnresolvedReference); cache[name] = assembly; //Console.WriteLine("added {0}; cache now contains {1}", name, cache.Count); }
public CurrentState(TypeNode type, CurrentState oldState) { this.Type = type; this.Method = null; this.typeSuppressed = null; this.methodSuppressed = null; this.Assembly = oldState.Assembly; this.assemblySuppressed = oldState.assemblySuppressed; }
private CurrentState(Method method, CurrentState oldState) { this.Assembly = oldState.Assembly; this.assemblySuppressed = oldState.assemblySuppressed; this.Type = oldState.Type; this.typeSuppressed = oldState.typeSuppressed; this.Method = method; this.methodSuppressed = null; }
internal TypeNode GetTypeNodeFor(AssemblyNode assembly, Type t) { if (t.IsArray) { int rank = t.GetArrayRank(); Type et = t.GetElementType(); TypeNode type = assembly.GetType(Identifier.For(et.Namespace), Identifier.For(et.Name)); return type.GetArrayType(rank); } else { return assembly.GetType(Identifier.For(t.Namespace), Identifier.For(t.Name)); } }
public static TypeNode FindShadow(this TypeNode typeNode, AssemblyNode shadowAssembly) { if (typeNode.DeclaringType != null) { // nested type var parent = typeNode.DeclaringType.FindShadow(shadowAssembly); if (parent == null) return null; return parent.GetNestedType(typeNode.Name); } // namespace type return shadowAssembly.GetType(typeNode.Namespace, typeNode.Name); }
public CopyOutOfBandContracts(AssemblyNode targetAssembly, AssemblyNode sourceAssembly, ContractNodes contractNodes, ContractNodes targetContractNodes) { Contract.Requires(targetAssembly != null); Contract.Requires(sourceAssembly != null); Contract.Requires(contractNodes != null); if (targetAssembly == sourceAssembly) { // this happened when a reference assembly for mscorlib had the assembly name "mscorlib" // instead of "mscorlib.Contracts" because only one assembly named "mscorlib" can be // loaded throw new ExtractorException("CopyOutOfBandContracts was given the same assembly as both the source and target!"); } this.outOfBandDuplicator = new ForwardingDuplicator(targetAssembly, null, contractNodes, targetContractNodes); this.targetAssembly = targetAssembly; FuzzilyForwardReferencesFromSource2Target(targetAssembly, sourceAssembly); CopyMissingMembers(); // FixupMissingProperties(); shouldn't be needed with new duplicator }
// Constructors /// <summary> /// /// </summary> /// <param name="contractNodes"></param> /// <param name="targetContractNodes"></param> /// <param name="ultimateTargetAssembly">specify X if extracting from X.Contracts.dll, otherwise null</param> public ExtractorVisitor(ContractNodes /*!*/ contractNodes, AssemblyNode ultimateTargetAssembly, AssemblyNode realAssembly) : this(contractNodes, ultimateTargetAssembly, realAssembly, false, false) { Contract.Requires(contractNodes != null); Contract.Requires(realAssembly != null); }
private bool SkipThisTypeDueToMismatchInReferenceAssemblyPlatform(AssemblyNode ultimateTargetAssembly, TypeNode typeNode) { if (ultimateTargetAssembly == null) return false; if (typeNode == this.contractNodes.ContractClass) return false; // don't skip contract methods as we need to extract their contracts if (HelperMethods.IsCompilerGenerated(typeNode)) return false; // don't skip closures etc. var typeWithSeparateContractClass = HelperMethods.IsContractTypeForSomeOtherTypeUnspecialized(typeNode, this.contractNodes); if (typeWithSeparateContractClass != null) { typeNode = typeWithSeparateContractClass; // see if this one is skipped } // now see if we have corresponding target type if (typeNode.FindShadow(ultimateTargetAssembly) != null) return false; // have target return true; // skip it. }
private static TypeNode GetPossiblyNestedType(AssemblyNode assem, string namespaceName, string className) { Contract.Requires(assem != null); Contract.Requires(className != null); var ns = Identifier.For(namespaceName); string[] pieces = className.Split('.'); // Get outermost type string outerMost = pieces[0]; TypeNode t = assem.GetType(ns, Identifier.For(outerMost)); if (t == null) return null; for (int i = 1; i < pieces.Length; i++) { var piece = pieces[i]; t = t.GetNestedType(Identifier.For(piece)); if (t == null) return null; } return t; }
public void VisitForPostCheck(AssemblyNode assemblyNode) { this.VisitAssembly(assemblyNode); }
private AssemblyNode ReadAssembly(AssemblyNode.PostAssemblyLoadProcessor postLoadEvent){
private static ContractNodes IdentifyContractAssemblyIfReferenced(ContractNodes contracts, AssemblyNode assemblyToVisit) { Contract.Requires(assemblyToVisit != null); if (contracts != null) { AssemblyNode assemblyContractsLiveIn = contracts.ContractClass == null ? null : contracts.ContractClass.DeclaringModule as AssemblyNode; if (assemblyContractsLiveIn != null) { if (assemblyContractsLiveIn == assemblyToVisit) { return contracts; } string nameOfAssemblyContainingContracts = assemblyContractsLiveIn.Name; Contract.Assume(assemblyToVisit.AssemblyReferences != null); foreach (var ar in assemblyToVisit.AssemblyReferences) { Contract.Assume(ar != null); if (ar.Name == nameOfAssemblyContainingContracts) { // just do name matching to avoid loading the referenced assembly return contracts; } } } } return null; }
/// <summary> /// Tries to reuse or create the attribute /// </summary> private static InstanceInitializer GetRuntimeContractsAttributeCtor(AssemblyNode assembly) { EnumNode runtimeContractsFlags = assembly.GetType(ContractNodes.ContractNamespace, Identifier.For("RuntimeContractsFlags")) as EnumNode; Class RuntimeContractsAttributeClass = assembly.GetType(ContractNodes.ContractNamespace, Identifier.For("RuntimeContractsAttribute")) as Class; if (runtimeContractsFlags == null) { #region Add [Flags] Member flagsConstructor = RewriteHelper.flagsAttributeNode.GetConstructor(); AttributeNode flagsAttribute = new AttributeNode(new MemberBinding(null, flagsConstructor), null, AttributeTargets.Class); #endregion Add [Flags] runtimeContractsFlags = new EnumNode(assembly, null, /* declaringType */ new AttributeList(2), TypeFlags.Sealed, ContractNodes.ContractNamespace, Identifier.For("RuntimeContractsFlags"), new InterfaceList(), new MemberList()); runtimeContractsFlags.Attributes.Add(flagsAttribute); RewriteHelper.TryAddCompilerGeneratedAttribute(runtimeContractsFlags); runtimeContractsFlags.UnderlyingType = SystemTypes.Int32; Type copyFrom = typeof(RuntimeContractEmitFlags); foreach (System.Reflection.FieldInfo fi in copyFrom.GetFields()) { if (fi.IsLiteral) { AddEnumValue(runtimeContractsFlags, fi.Name, fi.GetRawConstantValue()); } } assembly.Types.Add(runtimeContractsFlags); } InstanceInitializer ctor = (RuntimeContractsAttributeClass == null) ? null : RuntimeContractsAttributeClass.GetConstructor(runtimeContractsFlags); if (RuntimeContractsAttributeClass == null) { RuntimeContractsAttributeClass = new Class(assembly, null, /* declaringType */ new AttributeList(), TypeFlags.Sealed, ContractNodes.ContractNamespace, Identifier.For("RuntimeContractsAttribute"), SystemTypes.Attribute, new InterfaceList(), new MemberList(0)); RewriteHelper.TryAddCompilerGeneratedAttribute(RuntimeContractsAttributeClass); assembly.Types.Add(RuntimeContractsAttributeClass); } if (ctor == null) { Block returnBlock = new Block(new StatementList(new Return())); Block body = new Block(new StatementList()); Block b = new Block(new StatementList()); ParameterList pl = new ParameterList(); Parameter levelParameter = new Parameter(Identifier.For("contractFlags"), runtimeContractsFlags); pl.Add(levelParameter); ctor = new InstanceInitializer(RuntimeContractsAttributeClass, null, pl, body); ctor.Flags = MethodFlags.Assembly | MethodFlags.HideBySig | MethodFlags.SpecialName | MethodFlags.RTSpecialName; Method baseCtor = SystemTypes.Attribute.GetConstructor(); b.Statements.Add(new ExpressionStatement(new MethodCall(new MemberBinding(null, baseCtor), new ExpressionList(ctor.ThisParameter)))); b.Statements.Add(returnBlock); body.Statements.Add(b); RuntimeContractsAttributeClass.Members.Add(ctor); } return ctor; }
/// <summary> /// Adds a flag to an assembly that designates it as having runtime contract checks. /// Does this by defining the type of the attribute and then marking the assembly with /// and instance of that attribute. /// </summary> /// <param name="assembly">Assembly to flag.</param> private void SetRuntimeContractFlag(AssemblyNode assembly) { InstanceInitializer ctor = GetRuntimeContractsAttributeCtor(assembly); ExpressionList args = new ExpressionList(); args.Add(new Literal(this.contractEmitFlags, ctor.Parameters[0].Type)); AttributeNode attribute = new AttributeNode(new MemberBinding(null, ctor), args, AttributeTargets.Assembly); assembly.Attributes.Add(attribute); }
public override void VisitAssembly(AssemblyNode assembly) { // Don't rewrite assemblies twice. if (ContractNodes.IsAlreadyRewritten(assembly)) { throw new RewriteException("Cannot rewrite an assembly that has already been rewritten!"); } this.module = assembly; this.AdaptRuntimeOptionsBasedOnAttributes(assembly.Attributes); // Extract all inline foxtrot contracts and place them in the object model. //if (this.extractContracts) { // new Extractor(rewriterNodes, this.Verbose, this.Decompile).Visit(assembly); //} base.VisitAssembly(assembly); this.runtimeContracts.Commit(); // Set the flag that indicates the assembly has been rewritten. SetRuntimeContractFlag(assembly); // Add wrapper types for call-site requires. We do it here to avoid visiting them multiple times foreach (TypeNode t in this.wrapperTypes.Values) { assembly.Types.Add(t); } // in principle we shouldn't have old and result left over, but because of the call-site requires copying // we end up having them in closures that were used in ensures but not needed at call site requires #if !DEBUG || true CleanUpOldAndResult cuoar = new CleanUpOldAndResult(); assembly = cuoar.VisitAssembly(assembly); #endif RemoveContractClasses rcc = new RemoveContractClasses(); rcc.VisitAssembly(assembly); }
/// <summary> /// For level, see TranslateLevel /// </summary> /// <param name="assemblyBeingRewritten"></param> /// <param name="rewriterNodes"></param> /// <param name="level"></param> public Rewriter(AssemblyNode assemblyBeingRewritten, RuntimeContractMethods runtimeContracts, Action<System.CodeDom.Compiler.CompilerError> handleError, bool inheritInvariantsAcrossAssemblies, bool skipQuantifiers) { Contract.Requires(handleError != null); // F: Contract.Requires(runtimeContracts != null); #region Find IDisposable.Dispose method TypeNode iDisposable = SystemTypes.IDisposable; if (iDisposable != null) { IDisposeMethod = iDisposable.GetMethod(Identifier.For("Dispose")); } #endregion this.runtimeContracts = runtimeContracts; this.assemblyBeingRewritten = assemblyBeingRewritten; this.rewriterNodes = runtimeContracts.ContractNodes; this.contractEmitFlags = TranslateLevel(this.runtimeContracts.RewriteLevel); this.contractEmitFlags |= RuntimeContractEmitFlags.InheritContracts; // default if (runtimeContracts.ThrowOnFailure) { this.contractEmitFlags |= RuntimeContractEmitFlags.ThrowOnFailure; } if (!runtimeContracts.UseExplicitValidation) { this.contractEmitFlags |= RuntimeContractEmitFlags.StandardMode; } this.m_handleError = handleError; this.InheritInvariantsAcrossAssemblies = inheritInvariantsAcrossAssemblies; this.skipQuantifiers = skipQuantifiers; }
public RuntimeContractMethods(TypeNode userContractType, ContractNodes contractNodes, AssemblyNode targetAssembly, bool throwOnFailure, int rewriteLevel, bool publicSurfaceOnly, bool callSiteRequires, int recursionGuard, bool hideFromDebugger, bool userExplicitValidation ) { this.contractNodes = contractNodes; this.targetAssembly = targetAssembly; this.ThrowOnFailure = throwOnFailure; this.RewriteLevel = rewriteLevel; this.PublicSurfaceOnly = publicSurfaceOnly; this.CallSiteRequires = callSiteRequires; this.regularRecursionGuard = recursionGuard; this.HideFromDebugger = hideFromDebugger; this.UseExplicitValidation = userExplicitValidation; // extract methods from user methods #region Get the user-specified rewriter methods (optional) REVIEW!! Needs a lot of error handling if (userContractType != null) { Method method = null; MethodList reqMethods = userContractType.GetMethods(Identifier.For("Requires"), SystemTypes.Boolean, SystemTypes.String, SystemTypes.String); for (int i = 0; i < reqMethods.Count; i++) { method = reqMethods[i]; if (method != null) { if (method.TemplateParameters == null || method.TemplateParameters.Count != 1) { /*if (method != null) */ this.requiresMethod = method; } else { this.requiresWithExceptionMethod = method; } } } method = userContractType.GetMethod(Identifier.For("Ensures"), SystemTypes.Boolean, SystemTypes.String, SystemTypes.String); if (method != null) this.ensuresMethod = method; method = userContractType.GetMethod(Identifier.For("EnsuresOnThrow"), SystemTypes.Boolean, SystemTypes.String, SystemTypes.String, SystemTypes.Exception); if (method != null) this.ensuresOnThrowMethod = method; method = userContractType.GetMethod(Identifier.For("Invariant"), SystemTypes.Boolean, SystemTypes.String, SystemTypes.String); if (method != null) this.invariantMethod = method; method = userContractType.GetMethod(Identifier.For("Assert"), SystemTypes.Boolean, SystemTypes.String, SystemTypes.String); if (method != null) this.assertMethod = method; method = userContractType.GetMethod(Identifier.For("Assume"), SystemTypes.Boolean, SystemTypes.String, SystemTypes.String); if (method != null) this.assumeMethod = method; // Need to make sure that the type ContractFailureKind is the one used in the user-supplied methods, which is not necessarily // the one that is defined in the assembly that defines the contract class. For instance, extracting/rewriting from a 4.0 assembly // but where the user-supplied assembly is pre-4.0. var mems = userContractType.GetMembersNamed(ContractNodes.ReportFailureName); TypeNode contractFailureKind = contractNodes.ContractFailureKind; //if (mems != null) { foreach(var mem in mems){ method = mem as Method; if (method == null) continue; if (method.Parameters.Count != 4) continue; if (method.Parameters[0].Type.Name != contractNodes.ContractFailureKind.Name) continue; if (method.Parameters[1].Type != SystemTypes.String) continue; if (method.Parameters[2].Type != SystemTypes.String) continue; if (method.Parameters[3].Type != SystemTypes.Exception) continue; this.failureMethod = method; contractFailureKind = method.Parameters[0].Type; break; } } if (this.failureMethod == null) { mems = userContractType.GetMembersNamed(ContractNodes.RaiseContractFailedEventName); // if (mems != null) { foreach (var mem in mems) { method = mem as Method; if (method == null) continue; if (method.Parameters.Count != 4) continue; if (method.Parameters[0].Type.Name.UniqueIdKey != contractNodes.ContractFailureKind.Name.UniqueIdKey) continue; if (method.Parameters[1].Type != SystemTypes.String) continue; if (method.Parameters[2].Type != SystemTypes.String) continue; if (method.Parameters[3].Type != SystemTypes.Exception) continue; this.raiseFailureEventMethod = method; contractFailureKind = method.Parameters[0].Type; break; } } } else { method = userContractType.GetMethod(ContractNodes.RaiseContractFailedEventName, contractFailureKind, SystemTypes.String, SystemTypes.String, SystemTypes.Exception); if (method != null) this.raiseFailureEventMethod = method; } if (this.raiseFailureEventMethod != null) { // either take all both RaiseContractFailedEvent and TriggerFailure or neither method = userContractType.GetMethod(ContractNodes.TriggerFailureName, contractFailureKind, SystemTypes.String, SystemTypes.String, SystemTypes.String, SystemTypes.Exception); if (method != null) this.triggerFailureMethod = method; } } #endregion Get the user-specified rewriter methods (optional) REVIEW!! Needs a lot of error handling }
public static TypeNode FindType(AssemblyNode startingPoint, Identifier ns, Identifier name) { return startingPoint.GetType(ns, name, true); }
/// <summary> /// This is used to reset the target platform information if mscorlib is specified as one of the /// reference assemblies or documented assemblies. /// </summary> /// <param name="assembly">The system assembly for the target platform (mscorlib)</param> private static void ResetMscorlib(AssemblyNode assembly) { TargetPlatform.Clear(); CoreSystemTypes.Clear(); CoreSystemTypes.SystemAssembly = assembly; CoreSystemTypes.Initialize(true, false); }
public virtual AssemblyNode VisitAssembly(AssemblyNode assembly) { if (assembly == null) return null; this.VisitModule(assembly); assembly.ModuleAttributes = this.VisitAttributeList(assembly.ModuleAttributes); assembly.SecurityAttributes = this.VisitSecurityAttributeList(assembly.SecurityAttributes); return assembly; }
private AssemblyNode ReadAssembly(){ #endif try{ AssemblyNode assembly = new AssemblyNode(new Module.TypeNodeProvider(this.GetTypeFromName), new Module.TypeNodeListProvider(this.GetTypeList), new Module.CustomAttributeProvider(this.GetCustomAttributesFor), new Module.ResourceProvider(this.GetResources), this.directory); assembly.reader = this; this.ReadModuleProperties(assembly); this.ReadAssemblyProperties(assembly); //Hashvalue, Name, etc. this.module = assembly; this.ReadAssemblyReferences(assembly); this.ReadModuleReferences(assembly); AssemblyNode cachedAssembly = this.GetCachedAssembly(assembly); if (cachedAssembly != null) return cachedAssembly; if (this.getDebugSymbols) assembly.SetupDebugReader(null); #if !MinimalReader if (postLoadEvent != null) { assembly.AfterAssemblyLoad += postLoadEvent; assembly.AfterAssemblyLoadProcessing(); } #endif return assembly; #if !FxCop }catch(Exception e){ if (this.module == null) return null; if (this.module.MetadataImportErrors == null) this.module.MetadataImportErrors = new ArrayList(); this.module.MetadataImportErrors.Add(e); return this.module as AssemblyNode; } #else }finally{}
// Visitor Overrides public override AssemblyNode VisitAssembly(AssemblyNode assembly) { if (assembly == null) return null; if (this.verbose) { Console.WriteLine("Extracting from {0}", assembly.Location); } if (ContractNodes.IsAlreadyRewritten(assembly)) { // if the assembly has an out of band contract, then get the contracts from the shadow assembly, so we don't // care if the assembly itself has been rewritten. return assembly; } this.isVB = IsVBAssembly(assembly); AssemblyNode a = base.VisitAssembly(assembly); //if (this.errorFound) { // throw new ExtractorException("Error found: cannot continue"); //} //AfterExtractionCleanup aec = new AfterExtractionCleanup(this.contractNodes); //a = aec.VisitAssembly(a); return a; }
public override void VisitAssembly(AssemblyNode assembly) { this.currentState = new CurrentState(assembly); if (ContractNodes.IsAlreadyRewritten(assembly)) { this.HandleError(new Error(1029, "Cannot extract contracts from rewritten assembly '" + assembly.Name + "'.", assembly.SourceContext)); return; } base.VisitAssembly(assembly); }
private bool IsVBAssembly(AssemblyNode assembly) { foreach (var r in assembly.AssemblyReferences) { if (r == null) continue; if (r.Name == "Microsoft.VisualBasic") return true; } return false; }
public static bool ExtractContracts(AssemblyNode /*!*/ assembly, AssemblyNode /*?*/ referenceAssembly, ContractNodes /*?*/ contracts, ContractNodes /*?*/ backupContracts, ContractNodes /*?*/ targetContractNodes, out ContractNodes /*?*/ contractNodesUsedToExtract, Action<CompilerError> /*?*/ errorHandler, bool useClousotExtractor) { Contract.Requires(assembly != null); AssemblyNode assemblyToVisit = referenceAssembly ?? assembly; // Try to use supplied contracts, if present. But don't just try extracting and somehow // figuring out if any contracts had been present. Instead, see if: // a) the contract methods are defined in the assembly we are extracting from, or // b) the assembly reference microsoft.contracts.dll (the backup contracts and we found that assembly) // c) the assembly we are extracting from has an external reference to the assembly // the supplied contract methods came from. // d) the contracts found in mscorlib // // see if the assembly references the backup contracts (Microsoft.Contracts.dll) contractNodesUsedToExtract = IdentifyContractAssemblyIfReferenced(backupContracts, assemblyToVisit); // see if assembly defines the contracts itself if (contractNodesUsedToExtract == null) { contractNodesUsedToExtract = ContractNodes.GetContractNodes(assemblyToVisit, errorHandler); } // see if the assembly references the supplied contract assembly if (contractNodesUsedToExtract == null) { contractNodesUsedToExtract = IdentifyContractAssemblyIfReferenced(contracts, assemblyToVisit); } // see if the contracts are in the system assembly if (contractNodesUsedToExtract == null && assemblyToVisit != SystemTypes.SystemAssembly) { contractNodesUsedToExtract = ContractNodes.GetContractNodes(SystemTypes.SystemAssembly, errorHandler); } if (contractNodesUsedToExtract == null) return false; var fSharp = false; // TODO: Thread the program options through here somehow and let this be specified as an option Contract.Assume(assemblyToVisit.Attributes != null); foreach (var attr in assemblyToVisit.Attributes) { Contract.Assume(attr != null); Contract.Assume(attr.Type != null); Contract.Assume(attr.Type.Name != null); Contract.Assume(attr.Type.Name.Name != null); if (attr.Type.Name.Name.Contains("FSharpInterfaceDataVersionAttribute")) { fSharp = true; break; } } var ultimateTarget = (referenceAssembly != null) ? assembly : null; Contract.Assert(assembly != null); ExtractorVisitor ev = useClousotExtractor ? new ClousotExtractor(contractNodesUsedToExtract, ultimateTarget, assembly, errorHandler) : new ExtractorVisitor(contractNodesUsedToExtract, ultimateTarget, assembly, false, fSharp); ev.Visit(assemblyToVisit); if (!useClousotExtractor) { FilterForRuntime eoar = new FilterForRuntime(contractNodesUsedToExtract, targetContractNodes); assemblyToVisit = eoar.TransformForTarget(assemblyToVisit); } if (referenceAssembly != null) { CopyOutOfBandContracts coob = new CopyOutOfBandContracts(assembly, referenceAssembly, contractNodesUsedToExtract, targetContractNodes); coob.VisitAssembly(referenceAssembly); } return true; }
private static void CheckIfPreloaded(AssemblyResolver resolver, AssemblyNode assemblyNode, AssemblyNode preloaded, ref bool isPreloadedAssembly) { Contract.Requires(preloaded == null || resolver != null); if (preloaded == null) return; resolver.PostLoadHook(preloaded); if (assemblyNode == preloaded) { isPreloadedAssembly = true; } }