public static CachePair Read(BinaryReader reader, IPsiSourceFile sourceFile)
    {
      IList<PsiRuleSymbol> ruleData = ReadRules(reader, sourceFile);
      IList<PsiOptionSymbol> optionData = ReadOptions(reader, sourceFile);

      return new CachePair(ruleData, optionData);
    }

 public XXLanguageXXFile(FileStatistics statistics, IPsiSourceFile psiSourceFile, XXLanguageXXProject project)
   : base(null)// TODO: add statistics
 {
   _psiSourceFile = psiSourceFile;
   _fullName      = psiSourceFile.GetLocation().FullPath;
   _project       = project;
 }

        public ILexerFactory GetMixedLexerFactory(IBuffer buffer, IPsiSourceFile sourceFile, PsiManager manager)
        {
            var LanguageService = RaconteurLanguage.Instance.LanguageService();

            return LanguageService == null ? null
                : LanguageService.GetPrimaryLexerFactory();
        }

 void ICache.MarkAsDirty(IPsiSourceFile sourceFile)
 {
     lock (lockObject)
     {
         dirtyFiles.Add(sourceFile);
     }
 }

        public ITreeNode Add(IPsiSourceFile sourceFile, string text, int start, int len)
        {
            var name = text.Substring(start, len);
              NitraDeclaredElement declaredElement;
              if (!_declaredElements.TryGetValue(name.ToLower(), out declaredElement))
            declaredElement = new NitraDeclaredElement(sourceFile.GetSolution(), name);

              if (name.Length > 0 && char.IsUpper(name[0]))
              {
            var node = new NitraDeclaration(declaredElement, sourceFile, name, start, len);
            declaredElement.AddDeclaration(node);
            _declaredElements.Add(name, declaredElement);
            return node;
              }
              else
              {
            List<NitraNameReference> refs;
            if (!_references.TryGetValue(declaredElement, out refs))
            {
              refs = new List<NitraNameReference>();
              _references.Add(declaredElement, refs);
            }

            var node = new NitraNameReference(sourceFile, name, start, len);
            refs.Add(node);
            return node;
              }
        }

 public static IList<DisposeMethodStatus> Build(IPsiSourceFile sourceFile)
 {
     var file = sourceFile.GetPsiFile<CSharpLanguage>(new DocumentRange(sourceFile.Document, 0)) as ICSharpFile;
     if (file == null)
         return null;
     return Build(file);
 }

		internal T4Parser([NotNull] T4Environment t4Environment, [NotNull] DirectiveInfoManager directiveInfoManager, [NotNull] ILexer lexer,
			[CanBeNull] IPsiSourceFile sourceFile) {
			_t4Environment = t4Environment;
			_directiveInfoManager = directiveInfoManager;
			_lexer = lexer;
			_sourceFile = sourceFile;
		}

        public IEnumerable<RegistrationInfo> Analyze(IPsiSourceFile sourceFile)
        {
            ICSharpFile cSharpFile;
            #if SDK70
            cSharpFile = sourceFile.GetTheOnlyPsiFile(CSharpLanguage.Instance) as ICSharpFile;
            #else
            cSharpFile = sourceFile.GetPsiFile(CSharpLanguage.Instance) as ICSharpFile;
            #endif
            if (cSharpFile == null)
            {
                return EmptyList<RegistrationInfo>.InstanceList;
            }

            var usingStatements = cSharpFile.Imports
                                            .Where(directive => !directive.ImportedSymbolName.QualifiedName.StartsWith("System"))
                                            .Select(directive => directive.ImportedSymbolName.QualifiedName).ToList();

            IContainerInfo matchingContainer = GetMatchingContainer(usingStatements);
            if (matchingContainer == null)
            {
                return EmptyList<RegistrationInfo>.InstanceList;
            }

            ISearchDomain searchDomain = searchDomainFactory.CreateSearchDomain(sourceFile);

            return ScanRegistrations(matchingContainer, searchDomain);
        }

        protected override bool IsSupported(IPsiSourceFile sourceFile)
        {
            if (sourceFile == null || !sourceFile.IsValid())
                return false;

            return sourceFile.IsLanguageSupported<CSharpLanguage>();
        }

		public ISelectedRange GetSelectedRange(IPsiSourceFile sourceFile, DocumentRange documentRange) {
			Pair<IT4File, IFile> pair = GetFiles(sourceFile, documentRange);
			IT4File t4File = pair.First;
			IFile codeBehindFile = pair.Second;

			if (t4File == null)
				return null;

			ITreeNode t4Node = t4File.FindNodeAt(documentRange);
			if (t4Node == null)
				return null;

			// if the current selection is inside C# code, use the C# extend selection directly
			if (codeBehindFile != null) {
				ISelectEmbracingConstructProvider codeBehindProvider = PsiShared.GetComponent<PsiProjectFileTypeCoordinator>()
					.GetByPrimaryPsiLanguageType(codeBehindFile.Language)
					.SelectNotNull(fileType => Shell.Instance.GetComponent<IProjectFileTypeServices>().TryGetService<ISelectEmbracingConstructProvider>(fileType))
					.FirstOrDefault();

				if (codeBehindProvider != null) {
					ISelectedRange codeBehindRange = codeBehindProvider.GetSelectedRange(sourceFile, documentRange);
					if (codeBehindRange != null)
						return new T4CodeBehindWrappedSelection(t4File, codeBehindRange);
				}
			}

			return new T4NodeSelection(t4File, t4Node);
		}

 private static void SaveInvocationData(ControlFlowElementData data, IVariableDeclaration variable,
     byte position, string name, int offset, IPsiSourceFile sourceFile)
 {
     data[variable] = VariableDisposeStatus.DependsOnInvocation;
     var invokedExpression = new InvokedExpressionData(name, offset, position, sourceFile);
     data.InvokedExpressions.Add(variable, invokedExpression);
 }

        protected static bool IsSupported(IPsiSourceFile sourceFile)
        {
            if (sourceFile == null || !sourceFile.IsValid())
                return false;

            return sourceFile.IsLanguageSupported<AngularJsLanguage>();
        }

 public PsiOptionSymbol(string name, int offset, string value, IPsiSourceFile psiSourceFile)
 {
   myName = name;
   myOffset = offset;
   myValue = value;
   myPsiSourceFile = psiSourceFile;
 }

    public void Process(IPsiSourceFile sourceFile, IRangeMarker rangeMarker, CodeCleanupProfile profile, IProgressIndicator progressIndicator)
    {
      var file = sourceFile.GetNonInjectedPsiFile<CSharpLanguage>();
      if (file == null)
        return;

      if (!profile.GetSetting(DescriptorInstance))
        return;

      CSharpElementFactory elementFactory = CSharpElementFactory.GetInstance(sourceFile.PsiModule);
      
      file.GetPsiServices().PsiManager.DoTransaction(
        () =>
          {
            using (_shellLocks.UsingWriteLock())
              file.ProcessChildren<IExpression>(
                expression =>
                  {
                    ConstantValue value = expression.ConstantValue;
                    if (value.IsInteger() && Convert.ToInt32(value.Value) == int.MaxValue)
                      ModificationUtil.ReplaceChild(expression, elementFactory.CreateExpression("int.MaxValue"));
                  }
                );
          },
        "Code cleanup");
    }

 public static DisposeCacheData Read(BinaryReader reader, IPsiSourceFile sourceFile)
 {
     var count = reader.ReadInt32();
     var statuses = new List<DisposeMethodStatus>(count);
     for (var i = 0; i < count; i++)
         statuses.Add(DisposeMethodStatus.Read(reader, sourceFile));
     return new DisposeCacheData(statuses);
 }

 public NitraDeclaration(NitraDeclaredElement nitraDeclaredElement, IPsiSourceFile sourceFile, string name, int start, int len)
 {
     _sourceFile = sourceFile;
       DeclaredName = name;
       NameIdentifier = new NitraNameDeclaration(sourceFile, name, start, len);
       NitraDeclaredElement = nitraDeclaredElement;
       this.AddChild(NameIdentifier);
 }

		// ReSharper disable once UnusedParameter.Local
		public T4SecondaryDocumentGenerationResult([NotNull] IPsiSourceFile sourceFile, [NotNull] string text, [NotNull] PsiLanguageType language,
			[NotNull] ISecondaryRangeTranslator secondaryRangeTranslator, [NotNull] ILexerFactory lexerFactory,
			[NotNull] T4FileDependencyManager t4FileDependencyManager, [NotNull] IEnumerable<FileSystemPath> includedFiles)
			: base(text, language, secondaryRangeTranslator, lexerFactory) {
			_sourceFile = sourceFile;
			_t4FileDependencyManager = t4FileDependencyManager;
			_includedFiles = new HashSet<FileSystemPath>(includedFiles);
		}

    public IFileStructure Run(IDaemonProcess process, IPsiSourceFile psiSourceFile, IContextBoundSettingsStore settingsStore, IFile file)
    {
      var psiFile = file as IPsiFile;
      if (psiFile == null)
        return null;

      return new PsiFileStructure(psiFile, settingsStore);
    }

 public IReferenceFactory CreateFactory(IPsiSourceFile sourceFile, IFile file)
 {
     if (sourceFile.PrimaryPsiLanguage.Is<CSharpLanguage>())
         return new CSharpPropertyDataReferenceFactory();
     if (sourceFile.PrimaryPsiLanguage.Is<VBLanguage>())
         return new VBPropertyDataReferenceProviderFactory();
     return null;
 }

 public override IPsiSourceFileProperties GetPsiProperties(IProjectFile projectFile, IPsiSourceFile sourceFile)
 {
     if (!projectFile.IsProjectReferencingNancyRazorViewEngine())
     {
         return base.GetPsiProperties(projectFile, sourceFile);
     }
     
     return new RazorMvcPsiProjectFileProperties(projectFile, sourceFile);
 }