public Event(Controller controller, BaseConstruct parentObject, CodeLanguage language, int nodeIndex)
     : base(controller)
 {
     ParentObject = parentObject;
     Language = language;
     Index = nodeIndex;
 }

 public async Task<CodeWithDifference> CreateDifferenceListing(CodeLanguage language, Mutant mutant, MutationResult mutationResult)
 {
     _log.Debug("CreateDifferenceListing in object: " + ToString() + GetHashCode());
     try
     {
         
         var whiteCode = await VisualizeOriginalCode(language, mutant);
         var mutatedCode = await VisualizeMutatedCode(language, mutationResult);
         CodePair pair = new CodePair
         {
             OriginalCode = whiteCode,
             MutatedCode = mutatedCode
         };
         return _differenceCreator.GetDiff(language, pair.OriginalCode, pair.MutatedCode);
     }
     catch (Exception e)
     {
         _log.Error(e);
         return new CodeWithDifference
         {
             Code = "Exception occurred while decompiling: " + e,
             LineChanges = Enumerable.Empty<LineChange>().ToList()
         };
     }
 }

 internal override void Read(NetIncomingMessage Message)
 {
     base.Read(Message);
     Language = (CodeLanguage)Enum.Parse(typeof(CodeLanguage), Message.ReadString());
     Location = (CodeLocation)Enum.Parse(typeof(CodeLocation), Message.ReadString());
     Source = Message.ReadString();
 }

        public static CompilerResults CompileAndRun(String source, CodeLanguage language = CodeLanguage.CSharp)
        {
            // Select the code provider based on the input file extension.
            var provider = language == CodeLanguage.CSharp ?
                CodeDomProvider.CreateProvider("CSharp") : CodeDomProvider.CreateProvider("VisualBasic");

            var cp = new CompilerParameters
            {
                GenerateExecutable = true,
                GenerateInMemory = true,
                TreatWarningsAsErrors = false
            };

            cp.ReferencedAssemblies.AddRange(refAssemblies);

            // Invoke compilation of the source code.
            CompilerResults cr = provider.CompileAssemblyFromSource(cp, source);
            CopyAssembly();

            if (cr.Errors.Count < 1)
            {
                var entry = cr.CompiledAssembly.GetTypes().Select(t => t.GetMethod("Main", BindingFlags.Static | BindingFlags.NonPublic))
                    .Single(m => m != null);

                entry.Invoke(null, new object[]{ null });
            }

            return cr;
        }

        public void Generate()
        {
            _model = (Model) _propertyBag["Generic.Model"];
            
            if (_model.GenerateMonoRailProject && !String.IsNullOrEmpty(_model.MonoRailProjectName) && !String.IsNullOrEmpty(_model.MonoRailProjectPath))
            {
                _dte = (DTE)_propertyBag["Generic.DTE"];
                if (_dte == null)
                {
                    throw new NullReferenceException("Could not get a reference to active DTE object.");
                }
                else
                {
                    _language = (CodeLanguage)_propertyBag["Generic.Language"];

                    Project project = null;
                    project = GetProject(_dte, _model.MonoRailProjectName);

                    if (project == null)
                    {
                        project =
                            CreateProject(_dte, _model.MonoRailProjectPath + Path.DirectorySeparatorChar + _model.MonoRailProjectName,
                                          _model.MonoRailProjectName);
                    }

                    CodeCompileUnit compileUnit = (CodeCompileUnit)_propertyBag["CodeGeneration.CodeCompileUnit"];
                    
                    // We will handle the first namespace by default.
                    if (compileUnit.Namespaces.Count > 0)
                    {
                        CodeNamespace ns = compileUnit.Namespaces[0];
                        List<CodeTypeDeclaration> classes = null;
                        if (ns.Types.Count > 0)
                        {
                            classes = new List<CodeTypeDeclaration>();
                            foreach (CodeTypeDeclaration type in ns.Types)
                            {
                                if (type.IsClass)
                                {
                                    foreach (CodeAttributeDeclaration attribute in type.CustomAttributes)
                                    {
                                        if (attribute.Name == "ActiveRecord")
                                        {
                                            classes.Add(type);
                                            break;
                                        }
                                    }
                                }
                            }

                            if (classes.Count > 0)
                            {
                                // TODO: ...
                            }
                        }
                    }
                }
            }
        }

		/// <summary>
		/// Initializes a new instance of the <strong>Implicit3DParameters</strong> class on
		/// the specified code, code language, left-top corner point, right-bottom corner point and
		/// grid factor.
		/// </summary>
		/// <param name="codeExpression">Code</param>
		/// <param name="codeLanguage">Code language</param>
		/// <param name="point3DA">Left-top corner point</param>
		/// <param name="point3DB">Right-bottom corner point</param>
		/// <param name="gridFactor">
		/// This parameter specify graphics details. Increasing of this parameter give more
		/// detailed graphic but decrease speed of evaluation.
		/// </param>
		public Implicit3DParameters(string codeExpression, CodeLanguage codeLanguage, Point3D point3DA, Point3D point3DB, int gridFactor)
		{
			_code = codeExpression;
			_codeLanguage = codeLanguage;
			_point3DA = point3DA;
			_point3DB = point3DB;
			_gridFactor = gridFactor;
		}

 public PropertyAccessor(Controller controller, BaseConstruct parentObject, AccessorTypes accessorType, string text, CodeLanguage language)
     : base(controller)
 {
     ParentObject = parentObject;
     AccessorType = accessorType;
     Text = text;
     Language = language;
 }

 public Parameter(Controller controller, BaseConstruct parentObject, string name, string dataType, CodeLanguage language)
     : this(controller)
 {
     ParentObject = parentObject;
     Name = name;
     DataType = dataType;
     Language = language;
 }

        public async Task<string> VisualizeMutatedCode(CodeLanguage language, MutationResult mutationResult)
        {
            

            var result = Visualize(language, mutationResult.MethodMutated, mutationResult.MutatedModules);
          //  _mutantsCache.Release(mutationResult);
            return result;
        }

		/// <summary>
		/// Initializes a new instance of the Explicit2DParameters class on the specified
		/// code, code language, left-top corner point, right-bottom corner point and area
		/// size.
		/// </summary>
		/// <param name="codeExpression">code</param>
		/// <param name="codeLanguage">Code language.</param>
		/// <param name="pointA">Left-top corner point</param>
		/// <param name="pointB">Right-bottom corner point</param>
		/// <param name="size">Area size.</param>
		public Explicit3DParameters(string codeExpression, CodeLanguage codeLanguage, Point2D pointA, Point2D pointB, Size size)
		{
			_code = codeExpression;
			_codeLanguage = codeLanguage;
			_pointA = pointA;
			_pointB = pointB;
			_areaSize = size;
		}

		/// <summary>
		/// Initializes a new instance of the <strong>Implicit2DParameters</strong> class on
		/// the specified code, code language, left-top corner point, right-bottom corner point,
		/// grid factor and area size.
		/// </summary>
		/// <param name="codeExpression">code</param>
		/// <param name="codeLanguage">Code language</param>
		/// <param name="pointA">Left-top corner point</param>
		/// <param name="pointB">Right-bottom corner point</param>
		/// <param name="gridFactor">
		/// This parameter specify graphics details. Increasing of this parameter give more
		/// detailed graphic but decrease speed of evaluation.
		/// </param>
		/// <param name="areaSize">Area size.</param>
		public Implicit2DParameters(string codeExpression, CodeLanguage codeLanguage, Point2D pointA, Point2D pointB, int gridFactor, Size areaSize)
		{
			_code = codeExpression;
			_codeLanguage = codeLanguage;
			_pointA = pointA;
			_pointB = pointB;
			_gridFactor = gridFactor;
			_areaSize = areaSize;
		}

 public Namespace(Controller controller, BaseConstruct parentObject, string name, CodeRoot parentCodeRoot, CodeLanguage language, int nodeIndex)
     : this(controller)
 {
     ParentObject = parentObject;
     Name = name;
     ParentCodeRoot = parentCodeRoot;
     Language = language;
     Index = nodeIndex;
 }

 public CodeWithDifference GetDiff(CodeLanguage language, string input1, string input2)
 {
     var diff = new StringBuilder();
     var lineChanges = CreateDiff(language, input1, input2, diff);
     return new CodeWithDifference
     {
         Code = diff.ToString(),
         LineChanges = lineChanges
     };
 }

        public override void GenerateEntities(string filePrefix, string nameSpace, Data.DbSyncScopeDescription desc, Dictionary<string, Dictionary<string, string>> colsMappingInfo, System.IO.DirectoryInfo dirInfo, CodeLanguage option, string serviceUri)
        {
            // First generate the custom Context file
            CodeCompileUnit compileUnit = GenerateContextFile(filePrefix, nameSpace, desc, serviceUri);
            CodeDomUtility.SaveCompileUnitToFile(compileUnit, option, CodeDomUtility.GenerateFileName(desc.ScopeName, dirInfo, filePrefix, "OfflineContext", option));

            // Then generate the file containing the actual entities
            compileUnit = GenerateEntitiesFile(nameSpace, desc, colsMappingInfo);
            CodeDomUtility.SaveCompileUnitToFile(compileUnit, option, CodeDomUtility.GenerateFileName(desc.ScopeName, dirInfo, filePrefix, "Entities", option));
        }

 public Interface(Controller controller, string name, List<string> modifiers, string interfaceBase, CodeLanguage language, BaseConstruct parentObject, int nodeIndex)
     : base(controller)
 {
     Name = name;
     InterfaceBase = interfaceBase;
     Language = language;
     Modifiers = modifiers;
     ParentObject = parentObject;
     Index = nodeIndex;
 }

 public Enumeration(Controller controller, string name, List<string> modifiers, string enumBase, BaseConstruct parentObject, CodeLanguage language, int nodeIndex)
     : base(controller)
 {
     Name = name;
     EnumBase = enumBase;
     Modifiers = modifiers;
     ParentObject = parentObject;
     Language = language;
     Index = nodeIndex;
 }

        protected SmartCodeProject(string name, string location, CodeLanguage language)
            : base(null)
        {
            ThrowUtil.ThrowIfNull(language);

            Name = name;
            _projectPath = location;
            _language = language;
            _ASTManager = language.CreateASTManager(this);
        }

        private List<LineChange> CreateDiff(CodeLanguage language, string input1, string input2, StringBuilder diff)
        {
            IEqualityComparer<string> eq = FunctionalExt.ValuedSwitch<CodeLanguage, IEqualityComparer<string>>(language)
                .Case(CodeLanguage.CSharp, () => new CSharpCodeLineEqualityComparer())
                .Case(CodeLanguage.IL, () => new ILCodeLineEqualityComparer())
                .GetResult();
            var differ = new AlignedDiff<string>(
                NormalizeAndSplitCode(input1),
                NormalizeAndSplitCode(input2),
                eq,
                new StringSimilarityComparer(),
                new StringAlignmentFilter());

            int line1 = 0, line2 = 0;

            var list = new List<LineChange>();
            foreach (var change in differ.Generate())
            {
                int startIndex = 0;
                switch (change.Change)
                {
                    case ChangeType.Same:
                        diff.AppendFormat("{0,4} {1,4} ", ++line1, ++line2);
                        diff.AppendFormat("  ");
                        diff.AppendLine(change.Element1);
                        break;
                    case ChangeType.Added:
                        startIndex = diff.Length;
                        diff.AppendFormat("     {1,4}  +  ", line1, ++line2);

                        diff.AppendLine(change.Element2);
                        list.Add(NewLineChange(LineChangeType.Add, diff, startIndex, diff.Length));
                        break;
                    case ChangeType.Deleted:
                        startIndex = diff.Length;
                        diff.AppendFormat("{0,4}       -  ", ++line1, line2);
                        diff.AppendLine(change.Element1);
                        list.Add(NewLineChange(LineChangeType.Remove, diff, startIndex, diff.Length));
                        break;
                    case ChangeType.Changed:
                        startIndex = diff.Length;
                        diff.AppendFormat("{0,4}      ", ++line1, line2);
                        diff.AppendFormat("(-) ");
                        diff.AppendLine(change.Element1);
                        list.Add(NewLineChange(LineChangeType.Remove, diff, startIndex, diff.Length));
                        startIndex = diff.Length;
                        diff.AppendFormat("     {1,4} ", line1, ++line2);
                        diff.AppendFormat("(+) ");
                        diff.AppendLine(change.Element2);
                        list.Add(NewLineChange(LineChangeType.Add, diff, startIndex, diff.Length));
                        break;
                }
            }
            return list;
        }

        public async Task<string> VisualizeMutatedCode(CodeLanguage language, MutationResult mutationResult)
        {
            var result = Visualize(language, mutationResult.MethodMutated, mutationResult.MutatedModules);//oryginalnie była tylko ta linijka i return

            if (mutationResult.AdditionalMethodsMutated != null && mutationResult.MethodMutated!=mutationResult.AdditionalMethodsMutated[0])
            {
                result += Visualize(language, mutationResult.AdditionalMethodsMutated[0], mutationResult.MutatedModules);
            }
            //  _mutantsCache.Release(mutationResult);*/
            return result;
        }

        internal SmartCodeProjectAHK(string name, string location, CodeLanguage language)
            : base(name, location, language)
        {
            _language = language as CodeLanguageAHKv1;

                //UpdateStdLib();

                _language.Settings.SettingsChanged += (s, e) => {
                        //UpdateStdLib();
                    };
        }