Beispiel #1
0
        private static bool TryCreateResolvers <T>(
            IWorkspaceResolverFactory <T> workspaceResolverFactory,
            WorkspaceConfiguration configuration,
            AbsolutePath mainConfigurationFile,
            PathTable pathTable,
            bool addBuiltInPreludeResolver,
            out List <IWorkspaceModuleResolver> resolvers,
            out IEnumerable <Failure> failures)
        {
            Contract.Ensures(Contract.Result <List <IWorkspaceModuleResolver> >() != null);
            Contract.EnsuresForAll(Contract.Result <List <IWorkspaceModuleResolver> >(), r => r != null);

            resolvers = new List <IWorkspaceModuleResolver>(configuration.ResolverSettings.Count + (addBuiltInPreludeResolver ? 1 : 0));

            var resolverFailures = new List <Failure>();

            var resolverSettings = new List <IResolverSettings>(configuration.ResolverSettings);

            // The built in resolver is generally not added only for some tests. Regular spec processing always adds it.
            if (addBuiltInPreludeResolver)
            {
                // We add a resolver that points to the built-in prelude at the end of the resolver collection
                // so the built-in prelude is used if no prelude is specified explicitly
                var builtInPreludeSettings = PreludeManager.GetResolverSettingsForBuiltInPrelude(mainConfigurationFile, pathTable);
                resolverSettings.Add(builtInPreludeSettings);
            }

            foreach (var resolverConfiguration in resolverSettings)
            {
                var maybeResolver = workspaceResolverFactory.TryGetResolver(resolverConfiguration);
                if (!maybeResolver.Succeeded)
                {
                    resolverFailures.Add(maybeResolver.Failure);
                }
                else
                {
                    var resolver = (IWorkspaceModuleResolver)maybeResolver.Result;
                    resolvers.Add(resolver);
                }
            }

            failures = resolverFailures;
            return(resolverFailures.Count == 0);
        }
Beispiel #2
0
        /// <nodoc/>
        public static bool TryCreate <T>(
            [CanBeNull] Workspace mainConfigurationWorkspace,
            IWorkspaceStatistics workspaceStatistics,
            IWorkspaceResolverFactory <T> workspaceResolverFactory,
            WorkspaceConfiguration configuration,
            PathTable pathTable,
            SymbolTable symbolTable,
            bool useDecorator,
            bool addBuiltInPreludeResolver,
            out IWorkspaceProvider workspaceProvider,
            out IEnumerable <Failure> failures)
        {
            // mainConfigurationWorkspace can be null for some tests
            var mainFile = mainConfigurationWorkspace != null ?
                           mainConfigurationWorkspace.ConfigurationModule.Definition.MainFile :
                           AbsolutePath.Invalid;

            if (!TryCreateResolvers(
                    workspaceResolverFactory,
                    configuration,
                    mainFile,
                    pathTable,
                    addBuiltInPreludeResolver,
                    out var resolvers,
                    out failures))
            {
                workspaceProvider = default(IWorkspaceProvider);
                return(false);
            }

            var provider = new WorkspaceProvider(workspaceStatistics, resolvers, configuration, pathTable, symbolTable);

            provider.m_mainConfigurationWorkspace = mainConfigurationWorkspace;

            workspaceProvider = useDecorator
                ? (IWorkspaceProvider) new WorkspaceProviderStatisticsDecorator(workspaceStatistics, provider)
                : provider;
            return(true);
        }