public static Instruction FindInstruction(AssemblyDefinition assembly, string typeName, string testMethodName, OpCode testInstruction)
		{
			MethodDefinition testMethod = FindMethod(assembly, typeName, testMethodName);
			Assert.IsNotNull(testMethod);

			return FindInstruction(testMethod, testInstruction);
		}

		void OutputAssembly (AssemblyDefinition assembly)
		{
			string directory = Context.OutputDirectory;

			CopyConfigFileIfNeeded (assembly, directory);

			switch (Annotations.GetAction (assembly)) {
			case AssemblyAction.Link:
				assembly.Write (GetAssemblyFileName (assembly, directory), SaveSymbols (assembly));
				break;
			case AssemblyAction.Copy:
				CloseSymbols (assembly);
				CopyAssembly (GetOriginalAssemblyFileInfo (assembly), directory, Context.LinkSymbols);
				break;
			case AssemblyAction.Delete:
				CloseSymbols (assembly);
				var target = GetAssemblyFileName (assembly, directory);
				if (File.Exists (target))
					File.Delete (target);
				break;
			default:
				CloseSymbols (assembly);
				break;
			}
		}

		void SweepAssembly (AssemblyDefinition assembly)
		{
			if (Annotations.GetAction (assembly) != AssemblyAction.Link)
				return;

			if (!IsMarkedAssembly (assembly)) {
				RemoveAssembly (assembly);
				return;
			}

			var types = new List<TypeDefinition> ();

			foreach (TypeDefinition type in assembly.MainModule.Types) {
				if (Annotations.IsMarked (type)) {
					SweepType (type);
					types.Add (type);
					continue;
				}

				if (type.Name == "<Module>")
					types.Add (type);
			}

			assembly.MainModule.Types.Clear ();
			foreach (TypeDefinition type in types)
				assembly.MainModule.Types.Add (type);
		}

    public static void SetHook(
        HookType hookType,
        AssemblyDefinition targetAssembly, string targetTypeName, string targetMethodName,
        AssemblyDefinition calleeAssembly, string calleeTypeName, string calleeMethodName)
    {
#if DEBUG
        Console.WriteLine("SetHook - {0}/{1}|{2} -> {3}/{4}|{5}", targetAssembly.Name.Name, targetTypeName, targetMethodName, calleeAssembly.Name.Name, calleeTypeName, calleeMethodName);
#endif
        TypeDefinition calleeTypeDefinition = calleeAssembly.MainModule.GetType(calleeTypeName);
        if (calleeTypeDefinition == null)
        {
            throw new Exception(string.Format("Error ({0}) : {1} is not found", calleeAssembly.Name, calleeTypeName));
        }

        MethodDefinition calleeMethod = GetMethod(calleeTypeDefinition, calleeMethodName);
        if (calleeMethod == null)
        {
            throw new Exception(string.Format("Error ({0}) : {1}.{2} is not found", calleeAssembly.Name, calleeTypeName, calleeMethodName));
        }

        TypeDefinition targetTypeDefinition = targetAssembly.MainModule.GetType(targetTypeName);
        if (targetTypeDefinition == null)
        {
            throw new Exception(string.Format("Error ({0}) : {1} is not found", targetAssembly.Name, targetTypeName));
        }

        MethodDefinition targetMethod = GetMethod(targetTypeDefinition, targetMethodName);
        if (targetMethod == null)
        {
            throw new Exception(string.Format("Error ({0}) : {1}.{2} is not found", targetAssembly.Name, targetTypeName, targetMethodName));
        }
        HookMethod(hookType, targetAssembly.MainModule, targetMethod, calleeMethod);
    }

 private void Rewrite(AssemblyDefinition assemblyDefinition)
 {
     foreach (ModuleDefinition moduleDefinition in assemblyDefinition.Modules)
     {
         Rewrite(moduleDefinition);
     }
 }

		protected override void ProcessAssembly (AssemblyDefinition assembly)
		{
			if (Annotations.GetAction (assembly) != AssemblyAction.Link)
				return;

			ProcessTypes (assembly.MainModule.Types);
		}

		void SweepAssembly (AssemblyDefinition assembly)
		{
			if (Annotations.GetAction (assembly) != AssemblyAction.Link)
				return;

			if (!IsMarkedAssembly (assembly)) {
				RemoveAssembly (assembly);
				return;
			}

			var types = assembly.MainModule.Types;
			var cloned_types = Clone (types);

			types.Clear ();

			foreach (TypeDefinition type in cloned_types) {
				if (Annotations.IsMarked (type)) {
					SweepType (type);
					types.Add (type);
					continue;
				}

				SweepReferences (assembly, type);
			}
		}

 public AssemblyResult ProcessAssembly(AssemblyDefinition assembly, ModuleResult[] moduleResults)
 {
     AssemblyResult result = new AssemblyResult(assembly.Name.Name);
     result.ModuleResults = moduleResults;
     result.Result = moduleResults.Sum(r => r.Result);
     return result;
 }

		public void VisitAssembly(AssemblyDefinition assembly)
		{						
			Log.DebugLine(this, "-----------------------------------"); 
			Log.DebugLine(this, "checking {0}", assembly.Name);				

			if (Aspell.Instance != null)
			{				
				string details = string.Empty;
				foreach (CustomAttribute attr in assembly.CustomAttributes)
				{
					foreach (object o in attr.ConstructorParameters)
					{
						string text = o.ToString();
						Unused.Value = CheckSpelling.Text(text, ref details);
					}
				}
				
				if (details.Length > 0)
				{
					details = "Words: " + details;
					Log.DebugLine(this, details);
					Reporter.AssemblyFailed(assembly, CheckID, details);
				}
			}
		}

        /// <summary>
        /// Discovers the tests in the Assembly.
        /// </summary>
        /// <param name="dllPath">The path to the DLL.</param>
        /// <param name="assembly">The loaded Assembly.</param>
        /// <returns>Tests in the Assembly</returns>
        protected override List<TestClass> DiscoverTestsInAssembly(string dll, AssemblyDefinition assembly)
        {
            var classes2 = new List<TestClass>();
            foreach (var type in assembly.MainModule.Types)
            {
                bool isMSTest = false;

                try
                {
                    var customAttributes = type.CustomAttributes;
                    if (customAttributes != null)
                    {
                        isMSTest = customAttributes.Any(attribute => attribute.AttributeType.FullName == typeof(TestClassAttribute).FullName);
                    }
                }
                catch { }

                if (isMSTest)
                {
                    var TestClass = new TestClass
                    {
                        DLLPath = dll,
                        Name = type.Name,
                        Namespace = type.Namespace,
                        TestType = TestType.MSTest
                    };

                    TestClass.TestMethods = DiscoverTestsInClass(type, TestClass);
                    classes2.Add(TestClass);
                }
            }
            return classes2;
        }

        public JSAssembly(AssemblyDefinition assembly)
        {
            if (assembly == null)
                throw new ArgumentNullException("assembly");

            Assembly = assembly;
        }

        public static MethodDefinition FindDecryptor(AssemblyDefinition asmDef)
        {
            foreach (var modDef in asmDef.Modules)
                foreach (var typeDef in modDef.Types)
                    foreach (var mDef in typeDef.Methods)
                    {
                        var signature = new ILSignature
                                            {
                                                Start = 1,
                                                StartOpCode = OpCodes.Nop,
                                                Instructions = new List<OpCode>
                                                                   {
                                                                       OpCodes.Callvirt,
                                                                       OpCodes.Stloc_0,
                                                                       OpCodes.Ldloc_0,
                                                                       OpCodes.Newarr,
                                                                       OpCodes.Stloc_1,
                                                                       OpCodes.Ldc_I4_0,
                                                                       OpCodes.Stloc_2
                                                                   }
                                            };

                        if (mDef.HasBody) {
                            if (SignatureFinder.IsMatch(mDef, signature))
                                return mDef;
                        }
                    }

            return null;
        }

        public bool Process(AssemblyDefinition def)
        {
            foreach (var type in def.MainModule.Types)
                ProcessType(def, type);

            return true;
        }

		public AssemblyTypeInfoGenerator(string assembly, string[] searchDirs)
		{
			this.assembly_ = AssemblyDefinition.ReadAssembly(assembly, new ReaderParameters
			{
				AssemblyResolver = AssemblyTypeInfoGenerator.AssemblyResolver.WithSearchDirs(searchDirs)
			});
		}

		public RuleResult CheckAssembly (AssemblyDefinition assembly)
		{
			// assembly must have an entry point to be examined
			MethodDefinition entry_point = assembly.EntryPoint;
			if (entry_point == null)
				return RuleResult.DoesNotApply;

			// RULE APPLIES

			// we have to check declaringType's visibility so 
			// if we can't get access to it (is this possible?) we abandon
			// also, if it is not public, we don't have to continue our work
			// - we can't reach Main () anyways
			TypeDefinition type = entry_point.DeclaringType.Resolve ();
			if (type == null || !type.IsPublic)
				return RuleResult.Success;

			// at last, if Main () is not public, then it's okay
			if (!entry_point.IsPublic)
				return RuleResult.Success;

			if (assembly.References (VisualBasic)) {
				Runner.Report (type, Severity.Medium, Confidence.High, "Reduce class or module visibility (from public).");
			} else {
				Runner.Report (entry_point, Severity.Medium, Confidence.Total, "Change method visibility to private or internal.");
			}
			return RuleResult.Failure;
		}

        public void EmitAssemblyEntryPoint (AssemblyDefinition assembly, MethodDefinition entryMethod, MethodSignature signature) {
            Formatter.WriteRaw("JSIL.SetEntryPoint");
            Formatter.LPar();

            Formatter.AssemblyReference(assembly);

            Formatter.Comma();

            var context = new TypeReferenceContext();
            Formatter.TypeReference(entryMethod.DeclaringType, context);

            Formatter.Comma();

            Formatter.Value(entryMethod.Name);

            Formatter.Comma();

            Formatter.MethodSignature(
                entryMethod, signature, context
            );

            Formatter.RPar();
            Formatter.Semicolon(true);

            Formatter.NewLine();
        }

		public BaseMergeReflectionVisitor (MergeContext context, AssemblyDefinition target, AssemblyDefinition source)
		{
			this.context = context;
			this.target = target;
			this.source = source;
			module = target.MainModule;
		}

 public IEnumerable<Change<MethodReference>> GetChangesBetween(AssemblyDefinition oldAssembly, AssemblyDefinition newAssembly)
 {
     var changeDetector = new MethodILChangeDetector();
     var oldCache = AssemblyTypeMethodMapBuilder.BuildFor(oldAssembly);
     var newCache = AssemblyTypeMethodMapBuilder.BuildFor(newAssembly);
     var differences = MapKeyDifferenceFinder.GetChangesBetween(oldCache, newCache);
     foreach (var method in newAssembly.AllNonIgnoredMethods())
     {
         var current = oldAssembly.MainModule.GetType(method.DeclaringType.FullName);
         if (current == null) continue;
         if (method.ContainsIgnoreAttribute()) continue;
         foreach (var oldMethod in current.Methods)
         {
             if (oldMethod.GetChangeCacheName() == method.GetChangeCacheName())
             {
                 if (changeDetector.AreDifferentIL(oldMethod,
                                                   method))
                 {
                     differences.Add(
                                     new Change<MethodReference>(
                         ChangeType.Modify, method.ThreadSafeResolve()));
                     break;
                 }
             }
         }
     }
     differences = IEnumerableResolver.ResolveCompilerGeneratedCode(differences);
     return differences;
 }

		public override void VisitAssemblyDefinition (AssemblyDefinition asm)
		{
			if (asm.Kind != AssemblyKind.Dll && asm.EntryPoint == null)
				throw new ReflectionException ("Assembly does not have an entry point defined");

			if ((asm.MainModule.Image.CLIHeader.Flags & RuntimeImage.ILOnly) == 0)
				throw new NotSupportedException ("Can not write a mixed mode assembly");

			foreach (ModuleDefinition module in asm.Modules)
				if (module.Image.CLIHeader.Metadata.VirtualAddress != RVA.Zero)
					ResetImage (module);

			asm.MetadataToken = new MetadataToken (TokenType.Assembly, 1);
			ReflectionWriter rw = asm.MainModule.Controller.Writer;
			rw.StructureWriter = this;

			m_mdWriter = rw.MetadataWriter;
			m_tableWriter = rw.MetadataTableWriter;
			m_rowWriter = rw.MetadataRowWriter;

			if (!rw.SaveSymbols)
				return;

			FileStream fs = m_binaryWriter.BaseStream as FileStream;
			if (fs != null)
				rw.OutputFile = fs.Name;
		}

        public Emitter(Compiler compiler)
        {
            Compiler = compiler;

              // create assembly object
              var name = new AssemblyNameDefinition("MirelleCompiled", new Version(1, 0, 0, 0));
              Assembly = AssemblyDefinition.CreateAssembly(name, "MirelleCompiled", ModuleKind.Console);

              var attr = typeof(STAThreadAttribute).GetConstructor(new Type[] { } );

              // register global method
              GlobalBody = new MethodDefinition("main", MethodAttributes.Static | MethodAttributes.Private | MethodAttributes.HideBySig, Assembly.MainModule.TypeSystem.Void);
              GlobalBody.CustomAttributes.Add(new CustomAttribute(AssemblyImport(attr)));
              RootNode.GlobalMethod = new MethodNode("main", new SignatureNode("void"), true, false, GlobalBody);
              RootNode.GlobalMethod.Scope = new Utils.Scope(GlobalBody);

              // register global type
              GlobalType = new TypeDefinition("MirelleCompiled", ".program", TypeAttributes.AutoClass | TypeAttributes.Public | TypeAttributes.SpecialName | TypeAttributes.BeforeFieldInit, Assembly.MainModule.TypeSystem.Object);
              Assembly.MainModule.Types.Add(GlobalType);
              GlobalType.Methods.Add(GlobalBody);
              Assembly.EntryPoint = GlobalBody;

              // register marker interfaces
              MirelleTypeInterface = AssemblyImport(typeof(MirelleStdlib.IMirelleType));
              MirelleEnumInterface = AssemblyImport(typeof(MirelleStdlib.IMirelleEnum));
        }