private static void ApplyRenameHotspots(
[NotNull] LiveTemplatesManager liveTemplatesManager, [NotNull] ITextControl textControl,
[NotNull] IForeachStatement statement, [NotNull] IList <string> namesCollection,
[CanBeNull] IReferenceExpression extraReference = null)
{
var variableDeclaration = statement.IteratorDeclaration;
var endSelectionRange = new TextRange(textControl.Caret.Offset());
var suggestTypeName = new MacroCallExpressionNew(new SuggestVariableTypeMacroDef());
var typeNameInfo = new HotspotInfo(
new TemplateField("type", suggestTypeName, 0),
variableDeclaration.VarKeyword.GetDocumentRange());
var nameRanges = new LocalList <DocumentRange>();
nameRanges.Add(variableDeclaration.NameIdentifier.GetDocumentRange());
if (extraReference != null)
{
var documentRange = extraReference.GetDocumentRange();
nameRanges.Add(documentRange);
endSelectionRange = new TextRange(documentRange.TextRange.EndOffset);
}
var variableNameInfo = new HotspotInfo(
new TemplateField("name", new NameSuggestionsExpression(namesCollection), 0),
nameRanges.ToArray());
var session = liveTemplatesManager.CreateHotspotSessionAtopExistingText(
statement.GetSolution(), endSelectionRange, textControl,
LiveTemplatesManager.EscapeAction.LeaveTextAndCaret, typeNameInfo, variableNameInfo);
session.Execute();
}
public override IEnumerable <ITemplateScopePoint> ProvideScopePoints(TemplateAcceptanceContext context)
{
var sourceFile = context.SourceFile;
if (sourceFile == null)
{
yield break;
}
var caretOffset = context.CaretOffset;
var prefix = LiveTemplatesManager.GetPrefix(caretOffset);
var documentOffset = caretOffset - prefix.Length;
if (!documentOffset.IsValid())
{
yield break;
}
var file = sourceFile.GetPsiFile <ShaderLabLanguage>(documentOffset);
if (file == null || !file.Language.Is <ShaderLabLanguage>())
{
yield break;
}
yield return(new InUnityShaderLabFile());
}
public ArgumentItem([NotNull] PrefixExpressionContext[] contexts, [NotNull] PostfixTemplateContext postfixContext)
: base("arg", contexts)
{
var executionContext = postfixContext.ExecutionContext;
myLookupItemsOwner = executionContext.LookupItemsOwner;
myTemplatesManager = executionContext.LiveTemplatesManager;
}
public ForEachExpressionItem([NotNull] PrefixExpressionContext context) : base("forEach", context)
{
var postfixContext = context.PostfixContext;
var settingsStore = postfixContext.Reference.GetSettingsStore();
myTemplatesManager = postfixContext.ExecutionContext.LiveTemplatesManager;
myUseBraces = settingsStore.GetValue(PostfixSettingsAccessor.BracesForStatements);
}
protected ForLookupItemBase([NotNull] string shortcut,
[NotNull] PrefixExpressionContext context,
[CanBeNull] string lengthName)
: base(shortcut, context)
{
var executionContext = context.PostfixContext.ExecutionContext;
myTemplatesManager = executionContext.LiveTemplatesManager;
myLengthName = lengthName;
}
public ParseItem([NotNull] string shortcut, [NotNull] PrefixExpressionContext context, bool isTryParse)
: base(shortcut, context)
{
myIsTryParse = isTryParse;
var executionContext = context.PostfixContext.ExecutionContext;
myTemplatesManager = executionContext.LiveTemplatesManager;
myLookupItemsOwner = executionContext.LookupItemsOwner;
}
protected IntroduceMemberLookupItem([NotNull] string shortcut,
[NotNull] PrefixExpressionContext context,
[NotNull] IType expressionType, bool isStatic)
: base(shortcut, context)
{
IsStatic = isStatic;
ExpressionType = expressionType;
var executionContext = context.PostfixContext.ExecutionContext;
myTemplatesManager = executionContext.LiveTemplatesManager;
myMemberNames = EmptyList <string> .InstanceList;
}
public override IEnumerable <ITemplateScopePoint> ProvideScopePoints(TemplateAcceptanceContext context)
{
if (!context.GetProject().IsUnityProject())
{
yield break;
}
var sourceFile = context.SourceFile;
if (sourceFile == null)
{
yield break;
}
var caretOffset = context.CaretOffset;
var prefix = LiveTemplatesManager.GetPrefix(caretOffset);
var documentOffset = caretOffset - prefix.Length;
if (!documentOffset.IsValid())
{
yield break;
}
var psiFile = sourceFile.GetPrimaryPsiFile();
if (psiFile == null)
{
yield break;
}
if (psiFile.Language.Is <CSharpLanguage>())
{
yield return(new MustBeInUnityCSharpFile());
}
var element = psiFile.FindTokenAt(caretOffset - prefix.Length);
var typeDeclaration = element?.GetContainingNode <ITypeDeclaration>();
var unityApi = context.Solution.GetComponent <UnityApi>();
if (unityApi.IsUnityType(typeDeclaration?.DeclaredElement))
{
yield return(new MustBeInUnityType());
yield return(new MustBeInUnitySerializableType());
}
else if (unityApi.IsSerializableTypeDeclaration(typeDeclaration?.DeclaredElement))
{
yield return(new MustBeInUnitySerializableType());
}
}
protected override bool IsAvailable(ISpecificCodeCompletionContext context)
{
if (IsNormalProviderAvailable(context))
{
return(false);
}
if (!CanNormalProviderWork(context))
{
return(false);
}
var prefix = LiveTemplatesManager.GetPrefix(context.BasicContext.Document, context.BasicContext.CaretDocumentRange.TextRange.StartOffset, JsAllowedPrefixes.Chars);
return(prefix.Length > 0 && prefix.TrimStart(JsAllowedPrefixes.Chars).Length != prefix.Length);
}
public override IEnumerable <ITemplateScopePoint> ProvideScopePoints(TemplateAcceptanceContext context)
{
if (!context.GetProject().IsUnityProject())
{
yield break;
}
var sourceFile = context.SourceFile;
if (sourceFile == null)
{
yield break;
}
var caretOffset = context.CaretOffset;
var prefix = LiveTemplatesManager.GetPrefix(caretOffset);
var documentOffset = caretOffset - prefix.Length;
if (!documentOffset.IsValid())
{
yield break;
}
var psiFile = sourceFile.GetPrimaryPsiFile();
var element = psiFile?.FindTokenAt(caretOffset - prefix.Length);
var typeDeclaration = element?.GetContainingNode <ITypeDeclaration>();
if (typeDeclaration == null)
{
var siblingNode = element?.GetNextMeaningfulSibling();
while (siblingNode is IAttributeList)
{
siblingNode = element.GetNextMeaningfulSibling();
}
if (siblingNode is IClassDeclaration)
{
yield return(new IsAvailableForClassAttribute());
}
yield break;
}
var unityApi = context.Solution.GetComponent <UnityApi>();
if (unityApi.IsUnityType(typeDeclaration.DeclaredElement))
{
yield return(new MustBeInUnityType());
}
}
private bool IsAvailableOrExecuteEww([NotNull] ISolution solution, [NotNull] ITextControl textControl, bool execute)
{
var offset = textControl.Caret.Offset();
var prefix = LiveTemplatesManager.GetPrefix(textControl.Document, offset);
if (!TemplateWithNameExists(prefix))
{
return(false);
}
var files = textControl.Document.GetPsiSourceFiles(solution);
var allLanguages = files.SelectMany(file => file.GetPsiServices().Files.GetLanguages(file, PsiLanguageCategories.Primary)).Distinct();
foreach (var psiLanguageType in allLanguages)
{
var contextFactory = LanguageManager.Instance.TryGetService <IPostfixTemplateContextFactory>(psiLanguageType);
if (contextFactory == null)
{
continue;
}
foreach (var reparseString in contextFactory.GetReparseStrings())
{
var templateContext = TryReparseWith(solution, textControl, reparseString);
if (templateContext != null)
{
if (!templateContext.IsSemanticallyMakeSence())
{
return(false);
}
var templatesManager = LanguageManager.Instance.GetService <IPostfixTemplatesManager>(psiLanguageType);
if (execute)
{
var nameRange = TextRange.FromLength(offset - prefix.Length, prefix.Length);
templatesManager.ExecuteTemplateByName(templateContext, prefix, textControl, nameRange);
return(true);
}
return(templatesManager.IsTemplateAvailableByName(templateContext, prefix));
}
}
}
return(false);
}
protected override bool AddLookupItems(ISpecificCodeCompletionContext context, IItemsCollector collector)
{
var languageCaseProvider = LanguageManager.Instance.TryGetService <LanguageCaseProvider>(language);
var templateNames = new JetHashSet <string>(languageCaseProvider.IfNotNull(cp => cp.IsCaseSensitive()
? StringComparer.Ordinal
: StringComparer.OrdinalIgnoreCase));
IEnumerable <TemplateLookupItem> templateItems = TemplateActionsUtil.GetLookupItems(context.BasicContext.TextControl, context.BasicContext.CompletionManager.Solution, false, false);
var prefix = LiveTemplatesManager.GetPrefix(context.BasicContext.CaretDocumentOffset, JsAllowedPrefixes.Chars);
if (collector.Ranges == null)
{
var caretOffset = context.BasicContext.CaretDocumentOffset;
var prefixRange = new DocumentRange(caretOffset - prefix.Length, caretOffset);
collector.AddRanges(new TextLookupRanges(prefixRange, prefixRange));
}
if (!string.IsNullOrEmpty(prefix))
{
var identifierMatcher = LookupUtil.CreateMatcher(prefix, context.BasicContext.IdentifierMatchingStyle);
templateItems = templateItems.Where(item => identifierMatcher.Matches(item.Template.Shortcut));
}
foreach (var templateItem in templateItems)
{
templateNames.Add(templateItem.DisplayName.Text);
}
if (templateItems.IsEmpty())
{
return(false);
}
context.BasicContext.PutData(TemplateNamesKey, templateNames);
foreach (var templateItem in templateItems)
{
collector.Add(templateItem);
}
return(true);
}
private IPostfixLookupItem GetTemplateFromTextControl([NotNull] ISolution solution, [NotNull] ITextControl textControl)
{
var offset = textControl.Caret.Offset();
var prefix = LiveTemplatesManager.GetPrefix(textControl.Document, offset);
if (!TemplateWithNameExists(prefix))
{
return(null);
}
var postfixItems = TryReparseWith(solution, textControl, prefix, "__")
?? TryReparseWith(solution, textControl, prefix, "__;");
if (postfixItems == null)
{
return(null);
}
if (postfixItems.Count != 1)
{
return(null);
}
return(postfixItems[0]);
}
/// <summary>
/// Too lazy to implement full ITemplateScopePoint
/// </summary>
public IEnumerable <string> ProvideScopePoints(TemplateAcceptanceContext tacContext)
{
var solution = tacContext.Solution;
var document = tacContext.SelectionRange.Document;
if (document == null)
{
yield break;
}
var psiSource = tacContext.SourceFile;
if (psiSource == null)
{
yield break;
}
using (ReadLockCookie.Create())
{
var psiFiles = solution.GetPsiServices().Files;
if (!psiFiles.AllDocumentsAreCommitted)
{
psiFiles.CommitAllDocuments();
}
int caretOffset = tacContext.CaretOffset.Offset;
string prefix = LiveTemplatesManager.GetPrefix(document, caretOffset);
var documentRange = new DocumentRange(document, caretOffset - prefix.Length);
if (!documentRange.IsValid())
{
yield break;
}
yield return(psiSource.PrimaryPsiLanguage.Name);
var file = psiSource.GetPsiFile <CSharpLanguage>(documentRange);
if (file == null || !Equals(file.Language, CSharpLanguage.Instance))
{
yield break;
}
var element = file.FindTokenAt(document, caretOffset - prefix.Length);
if (element == null)
{
yield break;
}
yield return("InCSharpFile");
var treeNode = element;
if (treeNode.GetContainingNode <IDocCommentNode>(true) != null)
{
yield break;
}
if (treeNode is ICSharpCommentNode || treeNode is IPreprocessorDirective)
{
treeNode = treeNode.PrevSibling;
}
if (treeNode == null)
{
yield break;
}
var context = CSharpReparseContext.FindContext(treeNode);
if (context == null)
{
yield break;
}
if (treeNode.GetContainingNode <IEnumDeclaration>() != null)
{
yield return("InCSharpEnum");
}
var containingType = treeNode.GetContainingNode <ICSharpTypeDeclaration>(true);
if (containingType == null && TestNode <ICSharpNamespaceDeclaration>(context, "namespace N {}", false))
{
yield return("InCSharpTypeAndNamespace");
}
else if (TestNode <IMethodDeclaration>(context, "void foo() {}", false))
{
yield return("InCSharpTypeMember");
// Extend here:
// Already in type member,
if (treeNode.GetContainingNode <IInterfaceDeclaration>() != null)
{
yield return("InCSharpInterface");
}
if (treeNode.GetContainingNode <IClassDeclaration>() != null)
{
yield return("InCSharpClass");
}
if (treeNode.GetContainingNode <IStructDeclaration>() != null)
{
yield return("InCSharpStruct");
}
}
else
{
bool acceptsExpression = TestNode <IPostfixOperatorExpression>(context, "a++", true);
if (TestNode <IBreakStatement>(context, "break;", false))
{
yield return("InCSharpStatement");
}
else if (acceptsExpression)
{
yield return("InCSharpExpression");
}
if (!acceptsExpression && TestNode <IQuerySelectClause>(context, "select x", false))
{
yield return("InCSharpQuery");
}
}
}
}
public CastItem([NotNull] PrefixExpressionContext[] contexts, [NotNull] PostfixTemplateContext postfixContext)
: base("cast", contexts)
{
myTemplatesManager = postfixContext.ExecutionContext.LiveTemplatesManager;
}
public override string CalcPrefix(DocumentOffset caretOffset)
{
return(LiveTemplatesManager.GetPrefix(caretOffset, allowedPrefixChars));
}
public ForEachStatementItem([NotNull] PrefixExpressionContext context) : base("forEach", context)
{
myTemplatesManager = context.PostfixContext.ExecutionContext.LiveTemplatesManager;
}
public string CalcPrefix(IDocument document, int caretOffset)
{
return(document == null ? string.Empty : LiveTemplatesManager.GetPrefix(document, caretOffset, JsAllowedPrefixes.Chars));
}
public UsingItem([NotNull] PrefixExpressionContext context, bool shouldCreateVariable)
: base("using", context)
{
myTemplatesManager = context.PostfixContext.ExecutionContext.LiveTemplatesManager;
myShouldCreateVariable = shouldCreateVariable;
}
public AssignmentItem([NotNull] PrefixExpressionContext context) : base("to", context)
{
var executionContext = context.PostfixContext.ExecutionContext;
myTemplatesManager = executionContext.LiveTemplatesManager;
}
