C# IProjectFile.ToSourceFile方法代码示例

    internal XXLanguageXXFile TryAddFile(IProjectFile file)
    {
      XXLanguageXXFile nitraFile;
      if (!_filesMap.TryGetValue(file, out nitraFile))
      {
        var sourceFile = file.ToSourceFile();
        nitraFile = new XXLanguageXXFile(null /*TODO: add statistics*/, sourceFile, this);
        _filesMap.Add(file, nitraFile);
        _filePathsMap.Add(nitraFile.FullName, nitraFile);
      }

      return nitraFile;
    }

 protected ILexer CreateLexer(IProjectFile projectFile, StreamReader sr)
 {
     var lexer = this.CreateLexer(sr);
     if (lexer != null)
     {
         return lexer;
     }
     var buffer = new StringBuffer(sr.ReadToEnd());
     var sourceFile = projectFile.ToSourceFile();
     Assert.IsNotNull(sourceFile, "sourceFile == null");
     var lexerFactory = PsiProjectFileTypeCoordinator.Instance.CreateLexerFactory(this.Solution, sourceFile, buffer);
     Assert.IsNotNull(lexerFactory, "lexerFactory == null");
     return lexerFactory.CreateLexer(buffer);
 }

      public override void VisitProjectFile(IProjectFile projectFile)
      {
        base.VisitProjectFile(projectFile);
        using (ReadLockCookie.Create())
        {
          // Obtain document for visited project file and find all text occurences
          IDocument document = myDocumentManager.GetOrCreateDocument(projectFile);

          // Obtain lexer for projectFile if needed
          ILexer lexer = null;
          if (mySearchFlags != FindTextSearchFlags.All)
          {
            // Content should be provided to the following call, because sometimes lexer depends on content
            // E.g. ASP with C# or VB script language
            IBuffer contentBuffer = document.Buffer;
            var factory = PsiProjectFileTypeCoordinator.Instance;
            var lexerFactory = factory.CreateLexerFactory(mySolution, projectFile.LanguageType, contentBuffer, projectFile.ToSourceFile());
            if (lexerFactory != null)
            {
              lexer = lexerFactory.CreateLexer(contentBuffer);
              lexer.Start();
            }
          }

          foreach (int offset in mySearcher.FindAll(document.Buffer))
          {
            // create TextualOccurence for each found text and add to collection
            var textRange = new TextRange(offset, offset + mySearcher.Pattern.Length);

            if (lexer != null)
            {
              // Fastforward lexer to found location
              while (lexer.TokenEnd < offset)
                lexer.Advance();
            }

            if (lexer != null && lexer.TokenType != null)
            {
              var tokentype = lexer.TokenType;
              if ((mySearchFlags & FindTextSearchFlags.StringLiterals) == FindTextSearchFlags.None &&
                  tokentype.IsStringLiteral)
                continue;
              if ((mySearchFlags & FindTextSearchFlags.Comments) == FindTextSearchFlags.None && tokentype.IsComment)
                continue;
              if ((mySearchFlags & FindTextSearchFlags.Other) == FindTextSearchFlags.None &&
                  (!tokentype.IsComment && !tokentype.IsStringLiteral))
                continue;
            }
            else
            {
              if ((mySearchFlags & FindTextSearchFlags.Other) == FindTextSearchFlags.None)
                continue;
            }
            var options = new OccurencePresentationOptions();
            myItems.Add(new EmptyTextualOccurence(projectFile, textRange, options));
          }
        }
      }

        /// <summary>
        /// The skip analysis for document.
        /// </summary>
        /// <param name="projectFile">
        /// The project file.
        /// </param>
        /// <returns>
        /// True if analysis should be skipped.
        /// </returns>
        public bool SkipAnalysisForDocument(IProjectFile projectFile)
        {
            StyleCopTrace.In(projectFile);

            string cacheKey = string.Format("{0}::{1}", "SkipAnalysisForDocument", projectFile.Location.FullPath.ToLowerInvariant());

            bool result;

            if (BoolCache.TryGetValue(cacheKey, out result))
            {
                StyleCopTrace.Out();
                return result;
            }

            if (projectFile.Name.EndsWith(".cs"))
            {
                IContextBoundSettingsStore settingsStore = projectFile.ToSourceFile().GetSettingsStore();
                if (!settingsStore.GetValue((StyleCopOptionsSettingsKey key) => key.UseExcludeFromStyleCopSetting) || !projectFile.ProjectFileIsExcludedFromStyleCop())
                {
                    bool analyzeDesignerFiles = true;
                    bool analyzeGeneratedFiles = false;

                    BooleanProperty analyzeDesignerFilesSetting = this.GetParserSetting(projectFile, "AnalyzeDesignerFiles") as BooleanProperty;

                    if (analyzeDesignerFilesSetting != null)
                    {
                        analyzeDesignerFiles = analyzeDesignerFilesSetting.Value;
                    }

                    if (analyzeDesignerFiles || !projectFile.Name.EndsWith(".Designer.cs", StringComparison.OrdinalIgnoreCase))
                    {
                        BooleanProperty analyzeGeneratedFilesSetting = this.GetParserSetting(projectFile, "AnalyzeGeneratedFiles") as BooleanProperty;

                        if (analyzeGeneratedFilesSetting != null)
                        {
                            analyzeGeneratedFiles = analyzeGeneratedFilesSetting.Value;
                        }

                        if (analyzeGeneratedFiles
                            || (!projectFile.Name.EndsWith(".g.cs", StringComparison.OrdinalIgnoreCase)
                                && !projectFile.Name.EndsWith(".generated.cs", StringComparison.OrdinalIgnoreCase)))
                        {
                            BoolCache[cacheKey] = false;

                            StyleCopTrace.Out();

                            return false;
                        }
                    }
                }
            }

            BoolCache[cacheKey] = true;

            StyleCopTrace.Out();

            return true;
        }

        private IEnumerable<string> GetTypeNamesDefinedInFile(IProjectFile projectFile)
        {
            IPsiSourceFile psiSourceFile = projectFile.ToSourceFile();
            if (psiSourceFile == null)
                return EmptyList<string>.InstanceList;

            return psiSourceFile.GetPsiServices().Symbols.GetTypesAndNamespacesInFile(psiSourceFile)
                                .OfType<ITypeElement>()
                                .Select(element => element.ShortName);
        }