setup(async() => {
   ({analyzer} =
        await ProjectConfig.initializeAnalyzerFromDirectory(fixtures_dir));
   warningPrinter = new WarningPrettyPrinter();
   linter =
       new Linter(registry.getRules(['call-super-in-callbacks']), analyzer);
 });

 setup(async() => {
   ({analyzer} =
        await ProjectConfig.initializeAnalyzerFromDirectory(fixtures_dir));
   warningPrinter = new WarningPrettyPrinter();
   linter = new Linter(
       registry.getRules(['databinding-calls-must-be-functions']), analyzer);
 });

 setup(async () => {
   ({analyzer} =
        await ProjectConfig.initializeAnalyzerFromDirectory(fixtures_dir));
   warningPrinter = new WarningPrettyPrinter();
   linter = new Linter(
       registry.getRules(['databind-with-unknown-property']), analyzer);
 });

 async function createSettings(debugging?: boolean) {
   const {serverConnection, clientConnection, synchronizer, baseDir} =
       createFileSynchronizer(undefined, debugging);
   const {analyzer} =
       await ProjectConfig.initializeAnalyzerFromDirectory(baseDir);
   const settings = new Settings(serverConnection, synchronizer, analyzer);
   return {settings, serverConnection, clientConnection, baseDir};
 }

    test(`polymer team's elements lint clean`, async() => {
      const {analyzer} =
          await ProjectConfig.initializeAnalyzerFromDirectory(fixtures_dir);
      const linter =
          new Linter(registry.getRules(['polymer-2-hybrid']), analyzer);
      const warnings = filterWarnings((await linter.lintPackage()).warnings);

      const warningPrinter =
          new WarningPrinter(process.stdout, {color: true, verbosity: 'full'});
      warningPrinter.printWarnings(warnings);

      assert.equal(warnings.length, 0, 'Got unexpected warnings');
    });

 suiteSetup(async function() {
   // Building takes a few minutes.
   this.timeout(10 * 60 * 1000);
   await Promise.all([
     // Does not lint clean at the moment.
     // TODO: https://github.com/Polymer/tools/issues/274
     // runCommand(binPath, ['lint', '--rules=polymer-3'], {cwd: dir}),
     runCommand(binPath, ['build'], {cwd: dir}),
   ]);
   const config =
       ProjectConfig.loadConfigFromFile(path.join(dir, 'polymer.json'));
   if (config == null) {
     throw new Error('Failed to load shop\'s polymer.json');
   }
   assert.deepEqual(
       config.builds.map((b) => b.name || 'default').sort(),
       expectedBuildNames);
 });

export async function analyze(config: ProjectConfig, inputs: string[]):
    Promise<AnalysisFormat|undefined> {
  const {analyzer} = await config.initializeAnalyzer();

  const isInTests = /(\b|\/|\\)(test)(\/|\\)/;
  const isNotTest = (f: Feature) =>
      f.sourceRange != null && !isInTests.test(f.sourceRange.file);

  const projectSourceFiles = await getProjectSources({input: inputs}, config);

  if (projectSourceFiles == null) {
    const _package = await analyzer.analyzePackage();
    return generateAnalysis(_package, analyzer.urlResolver, isNotTest);
  } else {
    const analysis = await analyzer.analyze(projectSourceFiles);
    return generateAnalysis(analysis, analyzer.urlResolver, isNotTest);
  }
}

 connection.onInitialize(async(params): Promise<InitializeResult> => {
   // Normalize across the two ways that the workspace may be
   // communicated to us.
   const workspaceUri = getWorkspaceUri(params.rootUri, params.rootPath);
   if (!workspaceUri || workspaceUri.scheme !== 'file') {
     const error = new Error(
         `Got invalid workspaceUri from client: ` +
         `${util.inspect(workspaceUri)}`);
     reject(error);
     throw error;
   }
   const {urlResolver} =
       await ProjectConfig.initializeAnalyzerFromDirectory(
           workspaceUri.fsPath);
   const newServer = new LanguageServer(
       connection, workspaceUri, params.capabilities, urlResolver,
       loggingOptions.logToFile);
   resolve(newServer);
   return {capabilities: newServer.capabilities(params.capabilities)};
 });