internal bool CanInvokeRename(
ISyntaxFactsService syntaxFactsService,
IRenameTrackingLanguageHeuristicsService languageHeuristicsService,
bool isSmartTagCheck,
bool waitForResult,
CancellationToken cancellationToken)
{
if (IsRenamableIdentifier(_isRenamableIdentifierTask, waitForResult, cancellationToken))
{
var isRenamingDeclaration = _isRenamableIdentifierTask.Result == TriggerIdentifierKind.RenamableDeclaration;
var newName = TrackingSpan.GetText(TrackingSpan.TextBuffer.CurrentSnapshot);
var comparison = isRenamingDeclaration || syntaxFactsService.IsCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
if (!string.Equals(OriginalName, newName, comparison) &&
syntaxFactsService.IsValidIdentifier(newName) &&
languageHeuristicsService.IsIdentifierValidForRenameTracking(newName))
{
// At this point, we want to allow renaming if the user invoked Ctrl+. explicitly, but we
// want to avoid showing a smart tag if we're renaming a reference that binds to an existing
// symbol.
if (!isSmartTagCheck || isRenamingDeclaration || !NewIdentifierDefinitelyBindsToReference())
{
return(true);
}
}
}
return(false);
}
internal Definition(string documentation, DefinitionKind kind, Scope scope, TrackingSpan span)
{
this.Kind = kind;
this.Documentation = documentation;
this.Scope = scope;
this.DefinitionSpan = span;
}
public void Invoke(CancellationToken cancellationToken)
{
// Count the use of the tag
HugTags.I.Count(Item);
// Surround the selection with the tags
TrackingSpan.TextBuffer.Replace(TrackingSpan.GetSpan(Snapshot), Tagged);
}
public bool Contains(Snapshot snapshot, TrackingSpan span)
{
if (this.isBuiltIn)
{
return(true);
}
return(this.Contains(snapshot, span?.GetSpan(snapshot)));
}
public static ITrackingSpan ToITrackingSpan(this TrackingSpan span)
{
VSTrackingSpan trackingSpan = span as VSTrackingSpan;
if (trackingSpan == null)
{
throw new ArgumentException($"{nameof(span)} must be a VSTrackingSpan and not null");
}
return(trackingSpan.TrackingSpan);
}
internal void Advance(ITextVersion toVersion)
{
if (TrackingSpan != null)
{
TrackingSpan.GetSpan(toVersion);
}
foreach (var child in Children)
{
child.Advance(toVersion);
}
}
internal SyntaxToken(SyntaxTree tree, SyntaxType type, TrackingSpan span, string text, SyntaxTrivia leadingTrivia, SyntaxTrivia trailingTrivia, Snapshot snapshot, bool isMissing = false) : base(tree, type, span)
{
this.Text = text;
this.LeadingTrivia = leadingTrivia;
this.TrailingTrivia = trailingTrivia;
int start = this.HasLeadingTrivia ? this.LeadingTrivia.Span.GetSpan(snapshot).Start : this.Span.GetSpan(snapshot).Start;
int end = this.HasTrailingTrivia ? this.TrailingTrivia.Span.GetSpan(snapshot).End : this.Span.GetSpan(snapshot).End;
this.fullSpan = snapshot.CreateTrackingSpan(GLSL.Text.Span.Create(start, end));
this.IsMissing = isMissing;
}
internal void CheckNewIdentifier(StateMachine stateMachine, ITextSnapshot snapshot)
{
AssertIsForeground();
_newIdentifierBindsTask = _isRenamableIdentifierTask.SafeContinueWithFromAsync(
async t => t.Result != TriggerIdentifierKind.NotRenamable &&
TriggerIdentifierKind.RenamableReference ==
await DetermineIfRenamableIdentifierAsync(
TrackingSpan.GetSpan(snapshot),
initialCheck: false).ConfigureAwait(false),
_cancellationToken,
TaskContinuationOptions.OnlyOnRanToCompletion,
TaskScheduler.Default);
QueueUpdateToStateMachine(stateMachine, _newIdentifierBindsTask);
}
public GLSLSignature(Definition definition, TrackingSpan trackingSpan, Snapshot snapshot, ITextView textView, ISignatureHelpSession session)
{
GLSL.Text.Span span = trackingSpan.GetSpan(snapshot);
this.ApplicableToSpan = snapshot.CreateTrackingSpan(GLSL.Text.Span.Create(span.Start, span.End - 1)).ToITrackingSpan();
this.Content = definition.ToString();
this.Documentation = definition.Documentation;
this.Parameters = new ReadOnlyCollection <IParameter>(definition.GetParameters(this));
this.textView = textView;
this.session = session;
this.textView.TextBuffer.Changed += this.TextBufferChanged;
this.textView.Caret.PositionChanged += this.CaretPositionChanged;
this.session.Dismissed += this.OnDismissed;
this.ComputeCurrentParamter(this.textView.TextBuffer.CurrentSnapshot);
}
private SyntaxToken CreateToken(SyntaxType type, TrackingSpan span, bool isMissing = false)
{
if (type == SyntaxType.IdentifierToken)
{
if (isMissing)
{
return(new IdentifierSyntax(this.tree, span, string.Empty, null, null, this.snapshot, isMissing));
}
return(new IdentifierSyntax(this.tree, span, this.CurrentToken.Text, this.CurrentToken.LeadingTrivia, this.CurrentToken.TrailingTrivia, this.snapshot, isMissing));
}
else
{
if (isMissing)
{
return(new SyntaxToken(this.tree, type, span, string.Empty, null, null, this.snapshot, isMissing));
}
return(new SyntaxToken(this.tree, type, span, this.CurrentToken.Text, this.CurrentToken.LeadingTrivia, this.CurrentToken.TrailingTrivia, this.snapshot));
}
}
public InterfaceBlockDefinition(IReadOnlyList <SyntaxType> typeQualifier, string typeName, string documentation, Scope scope, TrackingSpan span)
: this(typeQualifier, typeName, documentation, null, scope, span)
{
}
internal TypeNameSyntax(SyntaxTree tree, TrackingSpan span) : base(tree, SyntaxType.TypeName, span)
{
}
public InterfaceBlockDefinition(IReadOnlyList <SyntaxType> typeQualifier, string typeName, string documentation, List <FieldDefinition> fields, Scope scope, TrackingSpan span)
: base(ColoredString.Create(typeName, ColorType.TypeName), documentation, DefinitionKind.InterfaceBlock, scope, span)
{
this.TypeQualifiers = typeQualifier ?? new List <SyntaxType>();
this.InternalFields = fields ?? new List <FieldDefinition>();
}
internal PrecisionDeclarationSyntax(SyntaxTree tree, TrackingSpan span) : base(tree, SyntaxType.PrecisionDeclaration, span)
{
}
internal ConstantExpressionSyntax(SyntaxTree tree, TrackingSpan span) : base(tree, SyntaxType.ConstantExpression, span)
{
}
internal TypeNameDefinition(string name, string documentation, Scope scope, TrackingSpan span)
: base(ColoredString.Create(name, ColorType.TypeName), documentation, DefinitionKind.TypeName, scope, span)
{
}
public ParameterDefinition(IReadOnlyList <SyntaxType> typeQualifier, TypeDefinition type, string identifier, string documentation, IReadOnlyList <ColoredString> arraySpecifiers, Scope scope, TrackingSpan span)
: base(ColoredString.Create(identifier, ColorType.Parameter), documentation, DefinitionKind.Parameter, scope, span)
{
this.TypeQualifiers = typeQualifier ?? new List <SyntaxType>();
this.Type = type;
this.ArraySpecifiers = arraySpecifiers ?? new List <ColoredString>();
}
internal ConstructorSyntax(SyntaxTree tree, TrackingSpan span) : base(tree, SyntaxType.Constructor, span)
{
}
internal WhileStatementSyntax(SyntaxTree tree, TrackingSpan span) : base(tree, SyntaxType.WhileStatement, span)
{
}
internal InterpolationQualifierSyntax(SyntaxTree tree, TrackingSpan span) : base(tree, SyntaxType.InterpolationQualifier, span)
{
}
protected ParameterDefinition(IReadOnlyList <SyntaxType> typeQualifier, TypeDefinition type, string identifier, string documentation, Scope scope, TrackingSpan span)
: this(typeQualifier, type, identifier, documentation, new List <ColoredString>(), scope, span)
{
}
internal StructDeclaratorSyntax(SyntaxTree tree, TrackingSpan span) : base(tree, SyntaxType.StructDeclarator, span)
{
}
internal IfDefinedPreprocessorSyntax(SyntaxTree tree, TrackingSpan span) : base(tree, SyntaxType.IfDefinedPreprocessor, span)
{
}
internal PrecisionQualifierSyntax(SyntaxTree tree, TrackingSpan span) : base(tree, SyntaxType.PrecisionQualifier, span)
{
}
public MacroDefinition(string name, IReadOnlyList <ColoredString> parameters, IReadOnlyList <ColoredString> tokenString, string documentation, Scope scope, TrackingSpan span)
: base(ColoredString.Create(name, ColorType.Macro), documentation, DefinitionKind.Macro, scope, span)
{
this.Parameters = parameters ?? new List <ColoredString>();
this.TokenString = tokenString ?? new List <ColoredString>();
}
internal ExpressionStatementSyntax(SyntaxTree tree, TrackingSpan span) : base(tree, SyntaxType.ExpressionStatement, span)
{
}
internal ReturnTypeSyntax(SyntaxTree tree, TrackingSpan span) : base(tree, SyntaxType.ReturnType, span)
{
}
internal TypeNameDefinition(string name, string documentation, List <FieldDefinition> fields, Scope scope, TrackingSpan span)
: base(ColoredString.Create(name, ColorType.TypeName), documentation, DefinitionKind.TypeName, scope, span)
{
this.InternalFields = fields;
}
internal BlockSyntax(SyntaxTree tree, TrackingSpan span) : base(tree, SyntaxType.Block, span)
{
}
internal PostfixArrayAccessSyntax(SyntaxTree tree, TrackingSpan span) : base(tree, SyntaxType.PostfixArrayAccess, span)
{
}
