private static bool HandleCommandLineArgs(string[] args)
        {
            bool status = true;
            options = new OptionSet
                          {
                              {"d", "Debug mode", v => option_compilationOptions |= CompilationOptions.DebugMode},
                              {"l|language=", "Custom language", v => option_customLanguage = v},
                              {"?|h|help", "Show help", v => { status = false; }},
                              {"<>", v => option_filename = v}
                          };
            try
            {
                options.Parse(args);
            }
            catch (OptionException)
            {
                status = false;
            }

            if (String.IsNullOrEmpty(option_filename))
            {
                status = false;
            }

            return status;
        }

 public static async Task<ExtractInterfaceTestState> CreateAsync(string markup, string languageName, CompilationOptions compilationOptions)
 {
     var workspace = languageName == LanguageNames.CSharp
         ? await TestWorkspace.CreateCSharpAsync(markup, exportProvider: ExportProvider, compilationOptions: compilationOptions as CSharpCompilationOptions)
         : await TestWorkspace.CreateVisualBasicAsync(markup, exportProvider: ExportProvider, compilationOptions: compilationOptions);
     return new ExtractInterfaceTestState(workspace);
 }

        internal CompilationVerifier CompileAndVerify(
            string[] sources,
            IEnumerable<MetadataReference> additionalRefs = null,
            IEnumerable<ModuleData> dependencies = null,
            Action<IModuleSymbol> sourceSymbolValidator = null,
            Action<PEAssembly> assemblyValidator = null,
            Action<IModuleSymbol> symbolValidator = null,
            SignatureDescription[] expectedSignatures = null,
            string expectedOutput = null,
            CompilationOptions options = null,
            ParseOptions parseOptions = null,
            bool verify = true)
        {
            if (options == null)
            {
                options = CompilationOptionsReleaseDll.WithOutputKind((expectedOutput != null) ? OutputKind.ConsoleApplication : OutputKind.DynamicallyLinkedLibrary);
            }

            var compilation = GetCompilationForEmit(sources, additionalRefs, options, parseOptions);

            return this.CompileAndVerify(
                compilation,
                null,
                dependencies,
                sourceSymbolValidator,
                assemblyValidator,
                symbolValidator,
                expectedSignatures,
                expectedOutput,
                verify);
        }

        public virtual void CodeCompilationIsCorrect()
        {
            // Arrange
            string inputFilePath = Path.Combine(_resourcesDirectoryPath,
                string.Format("variables/{0}/style{1}", _subfolderName, _fileExtension));
            string outputFilePath = Path.Combine(_resourcesDirectoryPath, "variables/style.css");

            string inputCode = File.ReadAllText(inputFilePath);
            string targetOutputCode = File.ReadAllText(outputFilePath);

            var options = new CompilationOptions
            {
                IndentedSyntax = _indentedSyntax
            };

            // Act
            CompilationResult result;

            using (var compiler = new SassCompiler())
            {
                result = compiler.Compile(inputCode, options: options);
            }

            // Assert
            Assert.Equal(targetOutputCode, result.CompiledContent);
            Assert.True(string.IsNullOrEmpty(result.SourceMap));
            Assert.Empty(result.IncludedFilePaths);
        }

 /// <param name="files">Can pass in multiple file contents: files will be named test1.cs, test2.cs, etc.</param>
 internal static TestWorkspace CreateWorkspaceFromFiles(
     string language,
     CompilationOptions compilationOptions,
     ParseOptions parseOptions,
     params string[] files)
 {
     return CreateWorkspaceFromFiles(language, compilationOptions, parseOptions, files, exportProvider: null);
 }

 Compilation ICompilationFactoryService.CreateSubmissionCompilation(string assemblyName, CompilationOptions options, Type hostObjectType)
 {
     return CSharpCompilation.CreateScriptCompilation(
         assemblyName,
         options: (CSharpCompilationOptions)options,
         previousScriptCompilation: null,
         globalsType: hostObjectType);
 }

        public override void WriteTo(CompilationOptions options, ObjectWriter writer, CancellationToken cancellationToken)
        {
            WriteCompilationOptionsTo(options, writer, cancellationToken);

            var csharpOptions = (CSharpCompilationOptions)options;
            writer.WriteValue(csharpOptions.Usings.ToArray());
            writer.WriteBoolean(csharpOptions.AllowUnsafe);
        }

 /// <param name="files">Can pass in multiple file contents: files will be named test1.cs, test2.cs, etc.</param>
 internal static Task<TestWorkspace> CreateAsync(
     string language,
     CompilationOptions compilationOptions,
     ParseOptions parseOptions,
     params string[] files)
 {
     return CreateAsync(language, compilationOptions, parseOptions, files, exportProvider: null);
 }

 /// <summary>
 /// Creates a single buffer in a workspace.
 /// </summary>
 /// <param name="content">Lines of text, the buffer contents</param>
 internal static Task<TestWorkspace> CreateWorkspaceFromFileAsync(
     string language,
     CompilationOptions compilationOptions,
     ParseOptions parseOptions,
     string content)
 {
     return CreateWorkspaceFromFilesAsync(language, compilationOptions, parseOptions, new[] { content });
 }

 protected override async Task<TestWorkspace> CreateWorkspaceFromFileAsync(string definition, ParseOptions parseOptions, CompilationOptions compilationOptions)
 {
     var workspace = await base.CreateWorkspaceFromFileAsync(definition, parseOptions, compilationOptions);
     workspace.Options = workspace.Options
         .WithChangedOption(AddImportOptions.SuggestForTypesInNuGetPackages, LanguageNames.CSharp, true)
         .WithChangedOption(AddImportOptions.SuggestForTypesInReferenceAssemblies, LanguageNames.CSharp, true);
     return workspace;
 }

 /// <param name="files">Can pass in multiple file contents with individual source kind: files will be named test1.vb, test2.vbx, etc.</param>
 public static Task<TestWorkspace> CreateWorkspaceFromFilesAsync(
     string[] files,
     ParseOptions[] parseOptions = null,
     CompilationOptions compilationOptions = null,
     ExportProvider exportProvider = null)
 {
     return TestWorkspaceFactory.CreateWorkspaceFromFilesAsync(LanguageNames.VisualBasic, compilationOptions, parseOptions, files, exportProvider);
 }

 public static Task<TestWorkspace> CreateWorkspaceFromFileAsync(
     string file,
     ParseOptions parseOptions = null,
     CompilationOptions compilationOptions = null,
     ExportProvider exportProvider = null,
     string[] metadataReferences = null)
 {
     return CreateWorkspaceFromFilesAsync(new[] { file }, parseOptions, compilationOptions, exportProvider, metadataReferences);
 }

 /// <summary>
 /// Creates a single buffer in a workspace.
 /// </summary>
 /// <param name="content">Lines of text, the buffer contents</param>
 internal static TestWorkspace CreateWorkspaceFromLines(
     string language,
     CompilationOptions compilationOptions,
     ParseOptions parseOptions,
     params string[] content)
 {
     var total = content.Join(Environment.NewLine);
     return CreateWorkspaceFromFiles(language, compilationOptions, parseOptions, total);
 }

        /// <summary>
        ///     Performs a synchronous compilation
        /// </summary>
        /// <param name="rebuild"></param>
        /// <param name="silent"></param>
        public void Compile_Synchronous(bool rebuild, bool silent = false)
        {
            Options = new CompilationOptions (rebuild, silent);
            ModelElement.DontRaiseError(Options.SilentCompile, () =>
            {
                try
                {
                    // Clears all caches
                    FinderRepository.INSTANCE.ClearCache();

                    // Initialises the declared elements
                    // ReSharper disable once UnusedVariable
                    CleanBeforeCompilation clean_before_compilation = new CleanBeforeCompilation(Options, true);

                    // Create the update information
                    // ReSharper disable once UnusedVariable
                    FindUpdates find_updates = new FindUpdates();

                    // Unifies the state machines and structure according to the update information
                    // ReSharper disable once UnusedVariable
                    Unify unify = new Unify();

                    // Compiles each expression and each statement encountered in the nodes
                    foreach (Dictionary dictionary in EfsSystem.Instance.Dictionaries)
                    {
                        visit(dictionary, true);
                    }

                    if (Options.Rebuild)
                    {
                        CreateDependancy create_dependancy = new CreateDependancy();
                        if (create_dependancy.DependancyChange)
                        {
                            // ReSharper disable once UnusedVariable
                            FlattenDependancy flatten_dependancy = new FlattenDependancy();
                        }
                    }
                }
                catch (ThreadAbortException)
                {
                    EfsSystem.Instance.ShouldRebuild = true;
                }
                catch (Exception e)
                {
                    // TODO : I don't know what to do.
                    // Please, at least, don't remove this
                    Debugger.Break();
                    Console.WriteLine();
                    Console.WriteLine(e.Message);
                    Console.WriteLine(e.StackTrace);
                    Console.WriteLine();
                    EfsSystem.Instance.ShouldRebuild = true;
                }
            });
        }

        public void SerializeCompilationOptions(CompilationOptions options, ObjectWriter writer, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            var language = options.Language;

            // TODO: once compiler team adds ability to serialize compilation options to ObjectWriter directly, we won't need this.
            writer.WriteString(language);

            var service = GetOptionsSerializationService(language);
            service.WriteTo(options, writer, cancellationToken);
        }

        /// <summary>
        ///     Constructor
        /// </summary>
        /// <param name="options"></param>
        /// <param name="clearCache"></param>
        public CleanBeforeCompilation(CompilationOptions options, bool clearCache)
        {
            ClearCaches = clearCache;
            Options = options;
            EfsSystem.Instance.InitDeclaredElements();

            foreach (Dictionary dictionary in EfsSystem.Instance.Dictionaries)
            {
                // ReSharper disable once DoNotCallOverridableMethodsInConstructor
                visit(dictionary, true);
            }
        }

        Compilation ICompilationFactoryService.CreateSubmissionCompilation(string assemblyName, CompilationOptions options, Type hostObjectType)
        {
#if SCRIPTING
            return CSharpCompilation.CreateSubmission(
                assemblyName,
                options: (CSharpCompilationOptions)options,
                previousSubmission: null,
                hostObjectType: hostObjectType);
#else
            throw new NotImplementedException();
#endif
        }

 //TODO: 4.6 should be the default for most testcases
 //      for now I do not want to do such a large change at once
 //      when 4.6 is the default, this override and ExpressionAssemblyRef below will not be needed.
 protected override Compilation GetCompilationForEmit(
     IEnumerable<string> source,
     IEnumerable<MetadataReference> additionalRefs,
     CompilationOptions options,
     ParseOptions parseOptions)
 {
     return CreateCompilationWithMscorlib46(
         Parse(source, options: (CSharpParseOptions)parseOptions),
         references: additionalRefs,
         options: (CSharpCompilationOptions)options,
         assemblyName: GetUniqueName());
 }

        protected void TestMissing(string initialMarkup, ParseOptions parseOptions, CompilationOptions compilationOptions, IDictionary<OptionKey, object> options = null, string fixAllActionEquivalenceKey = null)
        {
            using (var workspace = CreateWorkspaceFromFile(initialMarkup, parseOptions, compilationOptions))
            {
                if (options != null)
                {
                    ApplyOptionsToWorkspace(options, workspace);
                }

                var diagnostics = GetDiagnosticAndFix(workspace, fixAllActionEquivalenceKey);
                Assert.False(diagnostics?.Item2?.Fixes.IsEmpty == true);
            }
        }

        protected void WriteCompilationOptionsTo(CompilationOptions options, ObjectWriter writer, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            writer.WriteInt32((int)options.OutputKind);
            writer.WriteBoolean(options.ReportSuppressedDiagnostics);
            writer.WriteString(options.ModuleName);
            writer.WriteString(options.MainTypeName);
            writer.WriteString(options.ScriptClassName);
            writer.WriteInt32((int)options.OptimizationLevel);
            writer.WriteBoolean(options.CheckOverflow);

            // REVIEW: is it okay this being not part of snapshot?
            writer.WriteString(options.CryptoKeyContainer);
            writer.WriteString(options.CryptoKeyFile);

            writer.WriteValue(options.CryptoPublicKey.ToArray());
            writer.WriteBoolean(options.DelaySign.HasValue);
            if (options.DelaySign.HasValue)
            {
                writer.WriteBoolean(options.DelaySign.Value);
            }

            writer.WriteInt32((int)options.Platform);
            writer.WriteInt32((int)options.GeneralDiagnosticOption);

            writer.WriteInt32(options.WarningLevel);

            // REVIEW: I don't think there is a guarantee on ordering of elements in the immutable dictionary.
            //         unfortunately, we need to sort them to make it deterministic
            writer.WriteInt32(options.SpecificDiagnosticOptions.Count);
            foreach (var kv in options.SpecificDiagnosticOptions.OrderBy(o => o.Key))
            {
                writer.WriteString(kv.Key);
                writer.WriteInt32((int)kv.Value);
            }

            writer.WriteBoolean(options.ConcurrentBuild);
            writer.WriteBoolean(options.Deterministic);
            writer.WriteBoolean(options.PublicSign);

            // REVIEW: What should I do with these. we probably need to implement either out own one
            //         or somehow share these as service....
            //
            // XmlReferenceResolver xmlReferenceResolver
            // SourceReferenceResolver sourceReferenceResolver
            // MetadataReferenceResolver metadataReferenceResolver
            // AssemblyIdentityComparer assemblyIdentityComparer
            // StrongNameProvider strongNameProvider
        }