Scopes

Implementing a custom scope provider

The TemplateScopeManager shell component is the main entry point for working with scope points, and it maintains a list of IScopeProvider shell components. As such, it can be extended by a class implementing IScopeProvider and decorated with the [ShellComponent] attribute.

The IScopeProvider interface declares three methods that are used to create scope points:

public interface IScopeProvider
{
  IEnumerable<ITemplateScopePoint> ProvideScopePoints(TemplateAcceptanceContext context);
  ITemplateScopePoint ReadFromXml([NotNull] XmlElement scopeElement);
  ITemplateScopePoint CreateScope(Guid scopeGuid, string typeName, IEnumerable<Pair<string, string>> customProperties);
}

ProvideScopePoints - returns all scope points that are valid at the context described by the given TemplateAcceptanceContext instance, which provides details about file and text caret position. Parameterised scope points are either set to a reasonable value (for example, C# scope points can set a language version of 3.0 when the current context is in a LINQ query), or replaced by a scope point that makes more sense for the current context (instead of creating a file mask scope point of "*.*", a project file scope point is returned. This scope point knows how to compare itself against a file mask scope point used in a template)
ReadFromXml - used to read a scope point from an XML file. This is not typically used any more, as recent versions of ReSharper store and export templates in .dotSettings format, rather than the proprietary XML read by this method. However, the built-in providers still support this, in order to upgrade existing files in the old format. The complement to this method is the ITemplateScopePoint.WriteToXml method, which is still supported, but no longer exposed by ReSharper.
The ScopeProvider abstract base class used by all of the built-in providers will create a new instance based on the short type name in the type attribute of the XML element. Deriving classes should call the base method to create the instance, then populate it based on other attributes or child elements of the given XML element.
CreateScope should create an instance of ITemplateScopePoint based on the given short type name. It receives a GUID identifier that is unique for each template scope point instance (remember, scope points might be parameterised) and custom properties as string name/value pairs. This method is used to read the scope point from a .dotSettings file, which stores all information as name/value pairs.
Again, the ScopeProvider abstract base class will create a new instance based on the given type name and populate the ITemplateScopePoint.UID with the unique ID. Derived classes should call the base class and populate the new instance based on the custom properties.

The ScopeProvider abstract base class provides a mechanism for creating specific instances of ITemplateScopePoint based on a given type name. While it can simply instantiate the type based on the type name, it defers to a list of creator functions that take in the type name and create the scope point instance. This provides an extension point for custom creation, while also making it easy to create simple instances.

For example, the CSS scope provider will set up a list of creator functions that simply defer to ScopeProvider.TryToCreate<T> which will create the type if the type name matches:

public class CssScopeProvider : ScopeProvider
{
  public CssScopeProvider()
  {
    Creators.AddRange(new List<Func<string, ITemplateScopePoint>>
    {
      s => TryToCreate<InCssFile>(s),
      s => TryToCreate<InCssExpression>(s),
      s => TryToCreate<InCssStatement>(s),
    });
  }

  // ...
}

Example IScopeProvider.ProvideScopePoints implementation

The following is an example of an implementation of IScopeProvider.ProvideScopePoints for CSS files. It examines the current context, as provided by TemplateAcceptanceContext and returns scope points that are valid:

public override IEnumerable<ITemplateScopePoint> ProvideScopePoints(TemplateAcceptanceContext context)
{
  // Ensure we have an IPsiSourceFile, a valid document range, and the file is a CSS file
  if (context.SourceFile == null)
    yield break;

  var documentRange = new DocumentRange(context.Document, context.CaretOffset);
  if (!documentRange.IsValid())
    yield break;

  var file = context.SourceFile.GetPsiFile<CssLanguage>(documentRange);
  if (file == null)
    yield break;

  // Get the prefix at the text caret. This is treated as the shortcut that invokes the template
  // Then get the AST element that represents the prefix
  var prefix = LiveTemplatesManager.GetPrefix(context.Document, context.CaretOffset);
  var element = file.FindTokenAt(context.Document, context.CaretOffset - prefix.Length) as ITokenNode;

  if (element == null && String.IsNullOrEmpty(prefix))
  {
    if (context.Document.GetTextLength() == 0)
    {
      // There is no element at the caret, no known prefix and the document is empty
      // Valid scope points are anywhere in a CSS file, and anywhere a CSS statement is valid
      yield return new InCssFile();
      yield return new InCssStatement();
      yield break;
    }

    // If the caret is at the end of the file, get the token just before the EOF
    if (context.Document.GetTextLength() == context.CaretOffset)
      element = file.FindTokenAt(context.Document, context.CaretOffset - 1) as ITokenNode;
  }

  // There is no token, so no valid scope points
  if(element == null)
    yield break;

  var treeOffset = file.Translate(context.Document, context.CaretOffset);
  if (!treeOffset.IsValid())
    yield break;

  // Return a valid CSS file scope point
  yield return new InCssFile();

  // Look at the containing node, and return either a CSS expression or CSS statement scope point
  if (element.GetContainingNode<ICssPropertyValue>(true) != null || element.GetContainingNode<ICssExpression>(true) != null)
    yield return new InCssExpression();
  else if (element.GetContainingNode<ICssPropertyStatement>(true).IfNotNull(s => s.Property.IfNotNull(p => p.ColonToken.IfNotNull(n => n.GetTreeStartOffset() < element.GetTreeStartOffset()))))
    yield return new InCssExpression();
  else if (element.GetContainingNode<IMediaFeature>(true).IfNotNull(f => f.ColonToken.IfNotNull(n => n.GetTreeStartOffset() < element.GetTreeStartOffset())) )
    yield return new InCssExpression();
  else if(element.GetContainingNode<ICssPropertyStatement>(true) == null && element.GetContainingNode<IMediaFeature>(true) == null)
  {
    if (element.GetContainingNode<ICssBlock>() != null || element.GetContainingNode<IMediaQueryList>() != null)
      yield return new InCssStatement();
  }
}

The call to LiveTemplatesManager.GetPrefix gets the "word" that precedes the current text caret position. It is used here to find the position in the document that marks the start of the context of the scope point. This position is used to retrieve the node from the abstract syntax tree, which can then be used to see if the scope point is inside an expression or a statement, or so on.

A "word" is defined as any character preceding the current text caret that is a letter or digit, or is one of a set of allowed characters. The overload shown above does not specify any additional characters, so uses the default of the underscore character '_'. Another overload takes an array of allowed chars.

public static string GetPrefix(IDocument document, int caretOffset, params char[] allowedChars)

For example, the HTMLScopeProvider class calls GetPrefix with an array of { '_' } when fetching the prefix for file scope, and uses { '_', '<', ':' } when fetching the prefix for tag scope.

Implementing a custom scope point

A scope point is implemented by deriving from ITemplateScopePoint, and is usually implemented by deriving from the TemplateScopePoint abstract base class. It is not a component from the Component Model, but just a class created by an IScopeProvider. The interface is:

public interface ITemplateScopePoint
{
  bool IsSubsetOf(ITemplateScopePoint other);
  string Prefix { get; }
  string CalcPrefix(IDocument document, int caretOffset);
  [NotNull] XmlElement WriteToXml(XmlElement element);
  string PresentableShortName { get; }
  PsiLanguageType RelatedLanguage { get; }
  Guid UID { get; set; }
  Guid GetDefaultUID();
  string GetTagName();
  IEnumerable<Pair<string, string>>  EnumerateCustomProperties();
}

IMainScopePoint used by QuickListSupport, IScopeCategoryUIProvider and SupportedQuickList

Thanks for your feedback!

Was this page helpful?

Scopes﻿

Implementing a custom scope provider﻿

note

Example IScopeProvider.ProvideScopePoints implementation﻿

Implementing a custom scope point﻿

Scopes

Implementing a custom scope provider

Example IScopeProvider.ProvideScopePoints implementation

Implementing a custom scope point