public PsiIntentionResult(List<ITemplateFieldHolder> holders, IDeclaration declaration, ITreeNode anchor, DocumentRange range)
 {
   myDeclaration = declaration;
   myHolders = holders;
   myPrefferedSelection = range;
   myAnchor = anchor;
 }

 /// <summary>
 /// Returns a WhyBulb for the given highlighting.
 /// </summary>
 /// <param name="highlighting">Highlighting to process.</param>
 /// <param name="highlightingRange">Hihglighting range - not used here.</param>
 /// <returns></returns>
 public ICollection<IDisableHighlightingAction> Actions(IHighlighting highlighting, DocumentRange highlightingRange)
 {
     var cSharpHighlighting = highlighting as CSharpHighlightingBase;
     return (cSharpHighlighting == null)
                ? EmptyArray<IDisableHighlightingAction>.Instance
                : new IDisableHighlightingAction[] { new WhyBulb(highlighting.ErrorStripeToolTip, highlighting.GetType().Name) };
 }

        /// <summary>
        /// Gets the highlight for the specified StyleCop Violation.
        /// </summary>
        /// <param name="violation">
        /// The <see cref="StyleCop.ViolationEventArgs"/> instance containing the event data.
        /// </param>
        /// <param name="documentRange">
        /// <see cref="DocumentRange"/>where the Violation happened.
        /// </param>
        /// <param name="fileName">
        /// <see cref="CsElement"/>of the violation.
        /// </param>
        /// <param name="lineNumber">
        /// Line number where the violation happened.
        /// </param>
        /// <returns>
        /// An <see cref="IHighlighting"/> for the specified Violation.
        /// </returns>
        public static IHighlighting GetHighlight(ViolationEventArgs violation, DocumentRange documentRange, string fileName, int lineNumber)
        {
            string ruleID = violation.Violation.Rule.CheckId;
            string highlightID = HighlightingRegistering.GetHighlightID(ruleID);

            VSSolutionManager solutionManager = Shell.Instance.GetComponent<VSSolutionManager>();

            IContextBoundSettingsStore settingsStore = PsiSourceFileExtensions.GetSettingsStore(null, solutionManager.CurrentSolution);

            Severity severity = HighlightingSettingsManager.Instance.GetConfigurableSeverity(highlightID, settingsStore);

            switch (severity)
            {
                case Severity.ERROR:
                    return new StyleCopHighlightingError(violation, documentRange, fileName, lineNumber);
                case Severity.HINT:
                    return new StyleCopHighlightingHint(violation, documentRange, fileName, lineNumber);
                case Severity.INFO:
                    return new StyleCopHighlightingError(violation, documentRange, fileName, lineNumber);
                case Severity.SUGGESTION:
                    return new StyleCopHighlightingSuggestion(violation, documentRange, fileName, lineNumber);
                case Severity.WARNING:
                    return new StyleCopHighlightingWarning(violation, documentRange, fileName, lineNumber);
                default:
                    return new StyleCopHighlightingDoNotShow(violation, documentRange, fileName, lineNumber);
            }
        }

 public AttributeParamImpl(IXmlAttribute xmlAttribute,IParameterDescriptorProvider parameterDescriptorProvider)
 {
     name = xmlAttribute.AttributeName;
     nameDocumentRange = xmlAttribute.ToTreeNode().NameNode.GetDocumentRange();
     stringValue = xmlAttribute.UnquotedValue;
     this.parameterDescriptorProvider = parameterDescriptorProvider;
 }

        public static ICSharpStatement FixExpressionToStatement(DocumentRange expressionRange,
                                                            [NotNull] IPsiServices psiServices)
        {
            var solution = psiServices.Solution;
              var offset = expressionRange.TextRange.StartOffset;
              var document = expressionRange.Document;

              var expressions = TextControlToPsi.GetElements<IRazorImplicitExpression>(solution, document, offset);
              foreach (var razorExpression in expressions)
              {
            var razorRange = razorExpression.GetDocumentRange();

            const string commandName = "Replacing razor expression with statement";
            using (solution.CreateTransactionCookie(
              DefaultAction.Commit, commandName, NullProgressIndicator.Instance))
            {
              razorRange.Document.ReplaceText(razorRange.TextRange, "@using(null){}");
            }

            solution.GetPsiServices().CommitAllDocuments();

            var statements = TextControlToPsi.GetElements<IUsingStatement>(solution, document, offset);
            foreach (var razorStatement in statements)
            {
              return razorStatement;
            }

            break;
              }

              return null;
        }

        /// <summary>
        /// Gets the highlight for the specified StyleCop Violation.
        /// </summary>
        /// <param name="violation">
        /// The <see cref="StyleCop.ViolationEventArgs"/> instance containing the event data.
        /// </param>
        /// <param name="documentRange">
        /// <see cref="DocumentRange"/>where the Violation happened.
        /// </param>
        /// <param name="fileName">
        /// <see cref="CsElement"/>of the violation.
        /// </param>
        /// <param name="lineNumber">
        /// Line number where the violation happened.
        /// </param>
        /// <returns>
        /// An <see cref="IHighlighting"/> for the specified Violation.
        /// </returns>
        public static IHighlighting GetHighlight(ViolationEventArgs violation, DocumentRange documentRange, string fileName, int lineNumber)
        {
            string ruleID = violation.Violation.Rule.CheckId;
            string highlightID = HighlightingRegistering.GetHighlightID(ruleID);

            // To get the correct severity for a highlight we need to specify the current solution.
            ISolutionManager solutionManager = Shell.Instance.GetComponent<ISolutionManager>();
            Severity severity = HighlightingSettingsManager.Instance.GetConfigurableSeverity(highlightID, solutionManager.CurrentSolution);

            switch (severity)
            {
                case Severity.ERROR:
                    return new StyleCopViolationError(violation, documentRange, fileName, lineNumber);
                case Severity.HINT:
                    return new StyleCopViolationHint(violation, documentRange, fileName, lineNumber);
                case Severity.INFO:
                    return new StyleCopViolationError(violation, documentRange, fileName, lineNumber);
                case Severity.SUGGESTION:
                    return new StyleCopViolationSuggestion(violation, documentRange, fileName, lineNumber);
                case Severity.WARNING:
                    return new StyleCopViolationWarning(violation, documentRange, fileName, lineNumber);
                default:
                    return new StyleCopViolationDoNotShow(violation, documentRange, fileName, lineNumber);
            }
        }

		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);
		}

 /// <summary>Initializes a new instance of the <see cref="SuggestionBase"/> class.</summary>
 /// <param name="suggestionName">Name of the suggestion.</param>
 /// <param name="element">The element.</param>
 /// <param name="highlightingRange">The highlighting range.</param>
 /// <param name="toolTip">The tool tip.</param>
 protected SuggestionBase(string suggestionName, IElement element, DocumentRange highlightingRange, string toolTip)
 {
     this.range = highlightingRange;
       this.toolTip = toolTip;
       this.element = element;
       this.suggestionName = suggestionName;
 }

        public CreateMissedParameterFix(MissedParameterError missedParameterError)
        {
            if (missedParameterError == null)
                throw new ArgumentNullException("missedParameterError");

            this.missedParameterError = missedParameterError;
            headerNameRange = ((IXmlTag) missedParameterError.Element).ToTreeNode().Header.Name.GetDocumentRange();
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="StyleCopHighlightingBase"/> class.
 /// </summary>
 /// <param name="violationEventArgs">
 /// The <see cref="StyleCop.ViolationEventArgs"/> instance containing the Violation data.
 /// </param>
 /// <param name="documentRange">
 /// Range where the Violation happened.
 /// </param>
 protected StyleCopHighlightingBase(ViolationEventArgs violationEventArgs, DocumentRange documentRange)
 {
     this.CheckId = violationEventArgs.Violation.Rule.CheckId;
     this.ToolTip = violationEventArgs.Message + " [StyleCop Rule: " + this.CheckId + "]";
     this.documentRange = documentRange;
     this.Rule = violationEventArgs.Violation.Rule;
     this.Violation = violationEventArgs.Violation;
 }

 public NTriplesIntentionResult(
     List<ITemplateFieldHolder> holders, IDeclaration declaration, ITreeNode anchor, DocumentRange range)
 {
     this.myDeclaration = declaration;
     this.myHolders = holders;
     this.myPreferredSelection = range;
     this.myAnchor = anchor;
 }

 protected override Action<ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
 {
     var methodDeclaration = _highlighting.MethodDeclaration;
     methodDeclaration.SetExtern(false);
     var textRange = LanguageManager.Instance.GetService<IMemberBodyOperations>(methodDeclaration.Language).SetBodyToDefault(methodDeclaration);
     var rangeMarker = new DocumentRange(methodDeclaration.GetDocumentRange().Document, textRange).CreateRangeMarker(DocumentManager.GetInstance(solution));
     return control => control.Selection.SetRange(rangeMarker.Range);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="startLineNumber">Indexed from 1</param>
 /// <param name="endLineNumber">Indexed from 1</param>
 /// <param name="projectFile"></param>
 /// <param name="set"></param>
 /// <param name="range"></param>
 public Block(int startLineNumber, int endLineNumber, IProjectFile projectFile, Set set, DocumentRange? range)
 {
     Range = range;
     this.set = set;
     this.projectFile = projectFile;
     this.startLineNumber = startLineNumber;
     this.endLineNumber = endLineNumber;
 }

 private void AddHighLighting(DocumentRange range, ITreeNode element, IHighlightingConsumer consumer, IHighlighting highlighting)
 {
   var info = new HighlightingInfo(range, highlighting, new Severity?());
   IFile file = element.GetContainingFile();
   if (file != null)
   {
     consumer.AddHighlighting(info.Highlighting, file);
   }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="StyleCopViolationBase"/> class.
 /// </summary>
 /// <param name="violation">
 /// The <see cref="StyleCop.ViolationEventArgs"/> instance containing the Violation data.
 /// </param>
 /// <param name="documentRange">
 /// Range where the Violation happened.
 /// </param>
 /// <param name="fileName">
 /// The file Name.
 /// </param>
 /// <param name="lineNumber">
 /// Line number of where the violation happened.
 /// </param>
 protected StyleCopViolationBase(ViolationEventArgs violation, DocumentRange documentRange, string fileName, int lineNumber)
 {
     this.CheckId = violation.Violation.Rule.CheckId;
     this.ToolTip = violation.Message + " [StyleCop Rule: " + this.CheckId + "]";
     this.DocumentRange = documentRange;
     this.FileName = fileName;
     this.LineNumber = lineNumber;
     this.Rule = violation.Violation.Rule;
 }

        public void Execute(Action<DaemonStageResult> commiter)
        {
            try
            {
                // GetText gives the unsaved file contents, unlike file.ProjectFile.GetReadStream().
                string codeText = myDaemonProcess.Document.GetText();

            // I do not remember anymore why I created the Shallow version...
                var cloneFinder = new MethodsOnASingleClassCloneFinder(new ShallowExpansionFactory());
                //var cloneFinder = new MethodsOnASingleClassCloneFinder(new OscillatingExtractMethodExpansionFactory());

                cloneFinder.AddRefactoring(new LiteralToParameterExpansion());

                ScanResult scan_result = cloneFinder.GetCloneReplacements(codeText);
                if (scan_result != null)
                {
                    var document = myDaemonProcess.SourceFile.Document;

                    var Highlightings = new List<HighlightingInfo>();

                    foreach (var info in scan_result.Clones)
                    {
                        // We basically highlight the first line of the clone.
                        var start = document.GetLineStartOffset(((Int32<DocLine>) (info.HighlightStartLocationLine - 1))) + info.HighlightStartLocationColumn;
                        var end = start + info.HighlightLength;// Hmm, HighlightLength seems sort of arbitrary.
                        var warningHighlightRange = new DocumentRange(document, new TextRange(start, end));

                        // And this defines the chunk that gets replaced.
                        var replacedCodeRange = new DocumentRange(document,
                                                                  new TextRange(
                                                                      document.GetLineStartOffset(
                                                                          (Int32<DocLine>)
                                                                          (info.ReplacementSectionStartLine-1)),
                                                                      document.GetLineStartOffset(
                                                                          (Int32<DocLine>)
                                                                          info.ReplacementSectionEndLine)));

                        var highlight = new HighlightingInfo(warningHighlightRange,
                                                             new CloneDetectionHighlighting(info, replacedCodeRange));
                        Highlightings.Add(highlight);
                    }

                    // Creating container to put highlightings into.
                    DaemonStageResult ret = new DaemonStageResult(Highlightings);

                    commiter(ret);
                }
            }
            catch (Exception e)
            {
                System.Diagnostics.Debug.Write(e);
                throw;
            }
        }

        public static DocumentRange GetFooterTagRange(IElement element, DocumentRange range)
        {
            IXmlTag tag = element as IXmlTag;
            if (tag == null)
                return DocumentRange.InvalidRange;
            if (tag.ToTreeNode().Header.Name.GetDocumentRange().TextRange == range.TextRange)
            {
                IXmlTagFooterNode footer = tag.ToTreeNode().Footer;
                if (footer != null)
                    return footer.Name.GetDocumentRange();
            }

            return DocumentRange.InvalidRange;
        }

        public UnityColorReference(IColorElement colorElement, IExpression owningExpression, ITreeNode owner,
            DocumentRange colorConstantRange)
        {
            myOwningExpression = owningExpression;
            ColorElement = colorElement;
            Owner = owner;
            ColorConstantRange = colorConstantRange;

            BindOptions = new ColorBindOptions
            {
                BindsToName = true,
                BindsToValue = true
            };
        }

		private static Pair<IT4File, IFile> GetFiles([NotNull] IPsiSourceFile sourceFile, DocumentRange documentRange) {
			IT4File primaryFile = null;
			IFile secondaryFile = null;

			foreach (Pair<IFile, TreeTextRange> pair in sourceFile.EnumerateIntersectingPsiFiles(documentRange)) {
				var t4File = pair.First as IT4File;
				if (t4File != null)
					primaryFile = t4File;
				else
					secondaryFile = pair.First;
			}

			return Pair.Of(primaryFile, secondaryFile);
		}

        private static Pair<IT4File, IFile> GetFiles([NotNull] IPsiSourceFile sourceFile, DocumentRange documentRange)
        {
            IT4File primaryFile = null;
            IFile secondaryFile = null;

            foreach (IFile file in sourceFile.EnumeratePsiFiles(documentRange)) {
                var t4File = file as IT4File;
                if (t4File != null)
                    primaryFile = t4File;
                else
                    secondaryFile = file;
            }

            return Pair.Of(primaryFile, secondaryFile);
        }