public void CombiningWithOtherOptionsOverwrites()
        {
            var options = new CompilerOptions
            {
                AllowUnsafe = false,
                Optimize = true,
                WarningsAsErrors = true,
                LanguageVersion = "x"
            };

            var options2 = new CompilerOptions
            {
                AllowUnsafe = true,
                Optimize = false,
                WarningsAsErrors = false,
                LanguageVersion = "y",
            };

            var result = CompilerOptions.Combine(options, options2);

            Assert.True(result.AllowUnsafe.Value);
            Assert.False(result.Optimize.Value);
            Assert.False(result.WarningsAsErrors.Value);
            Assert.Equal("y", result.LanguageVersion);
        }

        private Parser GetParser()
        {
            if (_parser == null)
                {
                    using (var options = new CompilerOptions())
                    {
                        var sourceItems = new SourceItem[]{
                            new TextItem()
                            {

                                Name = "GdlGrammer", ContentType = TextItemType.MGrammar, Reader = new StringReader(Language)
                            }
                        };

                        options.AddSourceItems(sourceItems);

                        CompilationResults results = Compiler.Compile(options);
                        if (results.HasErrors)
                        {
                            //TODO: show meaningful error message
                            throw new Exception("Failed to compile GDL ....");
                        }
                        else
                        {
                            foreach (var parserFactory in results.ParserFactories)
                            {
                                //TODO: Why inside foreach loop!!!
                                _parser = parserFactory.Value.Create();
                            }
                        }
                    }
                }
                return _parser;
        }

        public CodePart Compile(int startLineNum, ParseTree tree, Context context, CompilerOptions options)
        {
            InitCompileFlags();

            part = new CodePart();
            this.context = context;
            this.options = options;
            this.startLineNum = startLineNum;

            ++context.NumCompilesSoFar;

            try
            {
                if (tree.Nodes.Count > 0)
                {
                    PreProcess(tree);
                    CompileProgram(tree);
                }
            }
            catch (KOSException kosException)
            {
                if (lastNode != null)
                {
                    throw;  // TODO something more sophisticated will go here that will
                    // attach source/line information to the exception before throwing it upward.
                    // that's why this seemingly pointless "catch and then throw again" is here.
                }
                SafeHouse.Logger.Log("Exception in Compiler: " + kosException.Message);
                SafeHouse.Logger.Log(kosException.StackTrace);
                throw;  // throw it up in addition to logging the stack trace, so the kOS terminal will also give the user some message.
            }

            return part;
        }

        public CodePart Compile(ParseTree tree, Context context, CompilerOptions options)
        {
            _part = new CodePart();
            _context = context;
            _options = options;

            try
            {
                if (tree.Nodes.Count > 0)
                {
                    PreProcess(tree);
                    CompileProgram(tree);
                }
            }
            catch (Exception e)
            {
                if (_lastNode != null)
                {
                    throw new Exception(string.Format("Error parsing {0}: {1}", ConcatenateNodes(_lastNode), e.Message));
                }
                else
                {
                    throw;
                }
            }

            return _part;
        }

        public void Test_That_Compiler_Returns_Response_As_Expected()
        {
            // Arrange
            const string ExpectedCompiledJavaScript = "{\"compiledCode\":\"alert(2);var a\\u003d(void 0).a.value,b\\u003d\\\"\\\";if(\\\"\\\"\\u003d\\u003da||-1\\u003d\\u003da.indexOf(\\\"@\\\"))b\\u003d\\\"please do something\\\";alert(\\\"\\\"\\u003d\\u003db);\",\"warnings\":[{\"type\":\"JSC_POSSIBLE_INEXISTENT_PROPERTY\",\"file\":\"Input_0\",\"lineno\":8,\"charno\":22,\"warning\":\"Property something never defined on frm\",\"line\":\"    var somevar \\u003d frm.something.value;\"},{\"type\":\"JSC_WRONG_ARGUMENT_COUNT\",\"file\":\"Input_0\",\"lineno\":19,\"charno\":6,\"warning\":\"Function dosomething: called with 0 argument(s). Function requires at least 1 argument(s) and no more than 1 argument(s).\",\"line\":\"alert(dosomething());\"}],\"statistics\":{\"originalSize\":372,\"originalGzipSize\":219,\"compressedSize\":103,\"compressedGzipSize\":113,\"compileTime\":0},\"outputFilePath\":\"/code/jsc533f6c7203b8d05105e273ac53810976/default.js\"}";

            // request and response data that will be used by the mock webrequest
            var requestStreamMock = new Mock<Stream>();
            var webResponseMock = new Mock<WebResponse>();
            var responseStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(ExpectedCompiledJavaScript));
            webResponseMock.Setup(m => m.GetResponseStream()).Returns(responseStream);

            // Mock of the webrequest tht will make the call to GCC
            var webRequestMock = new Mock<WebRequest>();
            webRequestMock.Setup(m => m.GetRequestStream()).Returns(requestStreamMock.Object);
            webRequestMock.Setup(m => m.GetResponse()).Returns(webResponseMock.Object);

            // Mock of file that will be read by the compiler
            var textReaderMock = new Mock<TextReader>();
            textReaderMock.Setup(m => m.ReadToEnd()).Returns("var x = 0;");

            var compilerOptions = new CompilerOptions(textReaderMock.Object, webRequestMock.Object, "A");
            var compiler = new JavaScriptCompiler(compilerOptions, new CompilationLevelHelper());

            // Act
            var actualCompiledJavaScript = compiler.Compile();

            Assert.Equal(ExpectedCompiledJavaScript, actualCompiledJavaScript);
        }

        public void GetOption(CompilerOptions optionID, IntPtr variant)
        {
            if (optionID < 0 || optionID >= CompilerOptions.LARGEST_OPTION_ID)
            {
                throw new ArgumentOutOfRangeException(nameof(optionID));
            }

            Marshal.GetNativeVariantForObject(_options[(int)optionID], variant);
        }

        /// <summary>
        /// Process a file
        /// </summary>
        /// <param name="file">File name</param>
        /// <param name="options">Compilation options</param>
        public void Process(string file, CompilerOptions options = CompilerOptions.None)
        {
            // clear compilation info if compilation
              if (options != CompilerOptions.ContinueCompilation)
            Init();

              ParseFile(file);
              Emitter.Prepare();
              Emitter.RootNode.Compile(Emitter);
        }

        public void CombiningWithNullSkipsNulls()
        {
            var options = new CompilerOptions
            {
                Optimize = true
            };

            var result = CompilerOptions.Combine(options, null);

            Assert.True(result.Optimize.Value);
        }

        public CompilerContext(SourceUnit sourceUnit, CompilerOptions options, ErrorSink errorSink, ParserSink parserSink) {
            ContractUtils.RequiresNotNull(sourceUnit, "sourceUnit");
            ContractUtils.RequiresNotNull(errorSink, "errorSink");
            ContractUtils.RequiresNotNull(parserSink, "parserSink");
            ContractUtils.RequiresNotNull(options, "options");

            _sourceUnit = sourceUnit;
            _options = options;
            _errors = errorSink;
            _parserSink = parserSink;
        }

        public Compilation(CompilationTest test)
        {
            _test = test;

            _references = new List<string>();
            _sources = new List<CompilationInput>();
            _resources = new List<CompilationInput>();

            _options = new CompilerOptions();
            _options.Minimize = false;
            _options.InternalTestMode = true;
            _options.Defines = new string[] { };
        }

        public void source_directory_is_mirrored_in_output([ValueSource("OutputFolderParameters")] string outputFolder)
        {
            var sourceDir = ExampleScripts.Valid.Hierarchy;

            var compilerOptions = new CompilerOptions
                                      {
                                          Compile = true,
                                          OutputDir = outputFolder,
                                          Path = sourceDir.ToString()
                                      };

            new Compiler().Compile(compilerOptions);

            AssertOutputMirrorsSource(compilerOptions.Path.AsDirectory(), compilerOptions.OutputDir.AsDirectory());
        }

        public int SetOptionWithMarshaledValue(CompilerOptions optionID, object value)
        {
            SetOption(ref _options[(int)optionID], value);

            if (optionID == CompilerOptions.OPTID_COMPATIBILITY)
            {
                // HACK: we want the project system to use the out-of-proc compiler rather than
                // us, because we really don't build much of anything yet. We can say we don't
                // support pretty much anything we want to do this. Let's just say we don't
                // support any version of C# yet

                return VSConstants.S_FALSE;
            }

            return VSConstants.S_OK;
        }

        public void CombiningConcatsDefines()
        {
            var options = new CompilerOptions
            {
                Defines = new[] { "OPT1" }
            };

            var options2 = new CompilerOptions
            {
                Defines = new[] { "OPT2" }
            };

            var result = CompilerOptions.Combine(options, options2);

            Assert.Equal(new[] { "OPT1", "OPT2" }, result.Defines);
        }

        public override List<CodePart> Compile(GlobalPath filePath, int startLineNum, string scriptText, string contextId, CompilerOptions options)
        {
            var parts = new List<CodePart>();
            ParseTree parseTree = parser.Parse(scriptText);
            if (parseTree.Errors.Count == 0)
            {
                var compiler = new Compiler();
                LoadContext(contextId);

                CodePart mainPart;
                try
                {
                    mainPart = compiler.Compile(startLineNum, parseTree, currentContext, options);
                }
                catch (KOSCompileException e)
                {
                    e.AddSourceText((short)startLineNum, scriptText);
                    throw;
                }

                // add locks and triggers
                parts.AddRange(currentContext.UserFunctions.GetNewParts());
                parts.AddRange(currentContext.Triggers.GetNewParts());
                parts.AddRange(currentContext.Subprograms.GetNewParts());

                parts.Add(mainPart);

                AssignSourceId(parts, filePath);

                //if (contextId != "interpreter") _cache.AddToCache(scriptText, parts);
            }
            else
            {
                // TODO: Come back here and check on the possibility of reporting more
                // errors than just the first one.  It appears that TinyPG builds a
                // whole array of error messages so people could see multiple syntax
                // errors in one go if we supported the reporting of it.  It may be that
                // it was deliberately not done because it might be too verbose that way
                // for the small text terminal.

                ParseError error = parseTree.Errors[0];
                throw new KOSParseException(error, scriptText);
            }

            return parts;
        }

        internal static CompilerOptions ParseOptions(string[] args, TextWriter infoWriter, TextWriter errorWriter)
        {
            if (args.Length == 0) {
                ShowHelp(infoWriter);
                return null;
            }

            try {
                bool showHelp = false;
                var result = new CompilerOptions() { MinimizeScript = true };
                var opts = new OptionSet {
                    { "outasm=",       v => result.OutputAssemblyPath = v },
                    { "outscript=",    v => result.OutputScriptPath = v },
                    { "doc=",          v => result.DocumentationFile = v },
                    { "d|define=",     v => result.DefineConstants.AddRange(v.Split(new[] { ';' }).Select(s => s.Trim()).Where(s => s != "" && !result.DefineConstants.Contains(s))) },
                    { "lib=",          v => result.AdditionalLibPaths.AddRange(v.Split(new[] { ',' }).Select(s => s.Trim()).Where(s => s != "" && !result.AdditionalLibPaths.Contains(s))) },
                    { "m|main=",       v => result.EntryPointClass = v },
                    { "r|reference=",  v => HandleReferences(result, v) },
                    { "debug",         f => result.MinimizeScript = f == null || f.EndsWith("-") },
                    { "w|warn=",       (int v) => { if (v < 0 || v > 4) throw new OptionException("Warning level must be between 0 and 4", "/warn"); result.WarningLevel = v; } },
                    { "nowarn=",       v => DisableWarnings(result, v) },
                    { "warnaserror:",  v => HandleWarningsAsErrors(result, v) },
                    { "warnaserror-:", v => HandleWarningsNotAsErrors(result, v) },
                    { "keyfile=",      v => result.KeyFile = v },
                    { "keycontainer=", v => result.KeyContainer = v },
                    { "t|target=",     v => result.HasEntryPoint = ParseTargetForHasEntryPoint(v) },
                    { "?|help",        v => showHelp = true },
                };

                var extra = opts.Parse(args);
                foreach (var file in extra)
                    result.SourceFiles.Add(file);

                if (showHelp) {
                    ShowHelp(infoWriter);
                    return null;
                }

                return result;
            }
            catch (OptionException ex) {
                errorWriter.WriteLine(ex.Message);
                return null;
            }
        }

        public ScriptTextWriter(TextWriter writer, CompilerOptions options)
            : base(CultureInfo.InvariantCulture) {
            _writer = writer;
            _globalWriter = writer;

#if DEBUG
            _minimize = options.Minimize && (options.InternalTestMode == false);
#else
            _minimize = options.Minimize;
#endif
            if (_minimize) {
                NewLine = "\n";
            }

            _tabString = "    ";
            _indentLevel = 0;
            _tabsPending = false;
        }

        public CodePart Compile(int startLineNum, ParseTree tree, Context context, CompilerOptions options)
        {
            InitCompileFlags();

            part = new CodePart();
            this.context = context;
            this.options = options;
            this.startLineNum = startLineNum;

            ++context.NumCompilesSoFar;

            if (tree.Nodes.Count > 0)
            {
                PreProcess(tree);
                CompileProgram(tree);
            }
            return part;
        }

        private void InvokeMethodInternal(InvokeParams invokeParams)
        {
            var invokeOptions = new InvokeOptions()
            {
                ClassName = invokeParams.TypeName,
                MethodName = invokeParams.MethodName,
                Async = true
            };

            var compilerOptions = new CompilerOptions()
            {
                FilePath = invokeParams.FilePath,
                ReferencedAssemblyPaths = BuildManager.GetReferencedAssemblies().OfType<Assembly>().Select(x => x.Location).ToArray(),
                SignKeyPath = invokeParams.KeyPath,
                OutputAssemblyName = invokeParams.AsmName
            };

            MethodInvoker.Execute(invokeOptions, compilerOptions);
        }

        public override List<CodePart> Compile(string scriptText, string contextId, CompilerOptions options)
        {
            List<CodePart> parts = null;

            // make the code lowercase
            scriptText = MakeLowerCase(scriptText);
            scriptText = ReplaceIdentifiers(scriptText);

            //if (contextId != "interpreter") parts = _cache.GetFromCache(scriptText);

            // if parts is null means the code doesn't exists in the cache
            if (parts == null)
            {
                parts = new List<CodePart>();
                ParseTree parseTree = parser.Parse(scriptText);
                if (parseTree.Errors.Count == 0)
                {
                    var compiler = new Compiler();
                    LoadContext(contextId);

                    // TODO: handle compile errors (e.g. wrong run parameter count)
                    CodePart mainPart = compiler.Compile(parseTree, currentContext, options);

                    // add locks and triggers
                    parts.AddRange(currentContext.Locks.GetNewParts());
                    parts.AddRange(currentContext.Triggers.GetNewParts());
                    parts.AddRange(currentContext.Subprograms.GetNewParts());

                    parts.Add(mainPart);

                    AssignInstructionId(parts);

                    //if (contextId != "interpreter") _cache.AddToCache(scriptText, parts);
                }
                else
                {
                    ParseError error = parseTree.Errors[0];
                    RaiseParseException(scriptText, error.Line, error.Position);
                }
            }

            return parts;
        }

        public Effect(GraphicsDevice graphicsDevice, byte[] effectCode, CompilerOptions options, EffectPool pool) 
        {
            int fragmentblocklength = BitConverter.ToInt32(effectCode, 0);

            int vertexblocklength = BitConverter.ToInt32(effectCode, fragmentblocklength + 4);

            if (fragmentblocklength != 0)
            {
                fragment_handle = Gl.glCreateShader(Gl.GL_FRAGMENT_SHADER);
                fragment = true;
            }

            if (vertexblocklength != 0)
            {
                vertex_handle = Gl.glCreateShader(Gl.GL_VERTEX_SHADER);
                vertex = true;
            }

            if (fragment)
            {
                string[] fragmentstring = new string[1] { Encoding.UTF8.GetString(effectCode, 4, fragmentblocklength) };
                int[] fragmentLength = new int[1] { fragmentstring[0].Length };
                Gl.glShaderSource(fragment_handle, 1, fragmentstring, fragmentLength);
            }

            if (vertex)
            {
                string[] vertexstring = new string[1] { Encoding.UTF8.GetString(effectCode, fragmentblocklength + 8, vertexblocklength) };
                int[] vertexLength = new int[1] { vertexstring[0].Length };
                Gl.glShaderSource(vertex_handle, 1, vertexstring, vertexLength);
            }

            if (fragment)
            {
                Gl.glCompileShader(fragment_handle);
            }

            if (vertex)
            {
                Gl.glCompileShader(fragment_handle);
            }
        }