private static void FixQualifierExpression([NotNull] ITextControl textControl, [NotNull] ICSharpExpression expression, [NotNull] ITypeElement ownerType)
{
var qualifierRange = expression.GetDocumentRange().TextRange;
var comparer = DeclaredElementEqualityComparer.TypeElementComparer;
// do not produce type qualifier when static method from containing type completed
var typeDeclaration = expression.GetContainingTypeDeclaration();
if (typeDeclaration != null && comparer.Equals(typeDeclaration.DeclaredElement, ownerType))
{
var reference = ReferenceExpressionNavigator.GetByQualifierExpression(expression).NotNull("reference != null");
var delimiter = reference.Delimiter;
if (delimiter != null)
{
qualifierRange = qualifierRange.JoinRight(delimiter.GetDocumentRange().TextRange);
}
textControl.Document.ReplaceText(qualifierRange, string.Empty);
}
else
{
var keyword = CSharpTypeFactory.GetTypeKeyword(ownerType.GetClrName());
textControl.Document.ReplaceText(qualifierRange, keyword ?? "T");
}
}
private string GetTypeString()
{
string keyword = CSharpTypeFactory.GetTypeKeyword(new ClrTypeName(TypeToken.GetText()));
if (keyword != null)
{
return(keyword);
}
return("global::" + GetTypeFqnString());
}
private static object GetTypeObject(UnityTypeSpec typeSpec, KnownTypesCache knownTypesCache, IPsiModule module)
{
if (typeSpec.TypeParameters.Length == 0)
{
var keyword = CSharpTypeFactory.GetTypeKeyword(typeSpec.ClrTypeName);
if (keyword != null)
{
return(keyword);
}
}
return(typeSpec.AsIType(knownTypesCache, module));
}
private void AppendDeclaredType([NotNull] IDeclaredType declaredType, QualifierDisplays expectedQualifierDisplay, Context context)
{
if (declaredType.IsNullable())
{
IType underlyingType = declaredType.GetNullableUnderlyingType();
if (underlyingType != null)
{
AppendTypeWithoutModule(underlyingType, expectedQualifierDisplay, context);
AppendText("?", _highlighterIdProvider.Operator);
return;
}
}
if (declaredType is IDynamicType)
{
AppendText("dynamic", _highlighterIdProvider.Keyword);
return;
}
if (context.Options.UseTypeKeywords)
{
string typeKeyword = CSharpTypeFactory.GetTypeKeyword(declaredType.GetClrName());
if (typeKeyword != null)
{
AppendText(typeKeyword, _highlighterIdProvider.Keyword);
return;
}
}
else if (declaredType.IsVoid())
{
AppendText("void", _highlighterIdProvider.Keyword);
return;
}
ITypeElement typeElement = declaredType.GetTypeElement();
if (typeElement == null || !typeElement.IsValid())
{
PsiLanguageType language = CSharpLanguage.Instance ?? (PsiLanguageType)UnknownLanguage.Instance;
AppendText(declaredType.GetPresentableName(language), null);
}
else
{
AppendTypeElement(typeElement, declaredType.GetSubstitution(), expectedQualifierDisplay, context);
}
}
public void AppendTypeMapped([NotNull] T4CSharpCodeGenerationResult result)
{
string typeText = TypeToken.GetText();
string keyword = CSharpTypeFactory.GetTypeKeyword(new ClrTypeName(typeText));
if (keyword != null)
{
result.Append(keyword);
return;
}
result.Append("global::");
if (CSharpLexer.IsKeyword(typeText))
{
result.Append("@");
}
result.AppendMapped(TypeToken);
}
private void AppendDeclaredType([NotNull] IDeclaredType declaredType, NamespaceDisplays expectedNamespaceDisplay)
{
if (declaredType.IsNullable())
{
IType underlyingType = declaredType.GetNullableUnderlyingType();
if (underlyingType != null)
{
AppendType(underlyingType, expectedNamespaceDisplay);
AppendText("?", VsHighlightingAttributeIds.Operator);
return;
}
}
if (declaredType is IDynamicType)
{
AppendText("dynamic", VsHighlightingAttributeIds.Keyword);
return;
}
if (_options.UseTypeKeywords)
{
string typeKeyword = CSharpTypeFactory.GetTypeKeyword(declaredType.GetClrName());
if (typeKeyword != null)
{
AppendText(typeKeyword, VsHighlightingAttributeIds.Keyword);
return;
}
}
else if (declaredType.IsVoid())
{
AppendText("void", VsHighlightingAttributeIds.Keyword);
return;
}
ITypeElement typeElement = declaredType.GetTypeElement();
if (typeElement == null || !typeElement.IsValid())
{
AppendText(declaredType.GetPresentableName(UnknownLanguage.Instance), null);
return;
}
AppendTypeElement(typeElement, declaredType.GetSubstitution(), expectedNamespaceDisplay);
}
private static AfterCompletionHandler BakeAfterComplete([NotNull] ILookupItem lookupItem, [NotNull] ISolution solution, int argumentsCount)
{
// sorry, ugly as f**k :(
return((ITextControl textControl, ref TextRange range, ref TextRange decoration,
TailType tailType, ref Suffix suffix, ref IRangeMarker caretMarker) =>
{
var psiServices = solution.GetPsiServices();
psiServices.CommitAllDocuments();
var allMethods = GetAllTargetMethods(lookupItem);
if (allMethods.Count == 0)
{
return;
}
var reference = TextControlToPsi.GetElement <IReferenceExpression>(solution, textControl.Document, range.StartOffset);
if (reference == null)
{
return;
}
var decorationText = textControl.Document.GetText(decoration);
var decorationRange = new DocumentRange(textControl.Document, decoration);
var hasMoreParameters = HasMoreParameters(allMethods, argumentsCount);
if (!hasMoreParameters) // put caret 'foo(arg){here};'
{
caretMarker = decorationRange.EndOffsetRange().CreateRangeMarker();
}
else if (argumentsCount > 0)
{
var parenthesisCloseIndex = decorationText.LastIndexOf(')');
if (parenthesisCloseIndex >= 0)
{
var delta = decoration.Length - parenthesisCloseIndex;
caretMarker = decorationRange.EndOffsetRange().Shift(-delta).CreateRangeMarker();
}
}
var qualifierExpression = reference.QualifierExpression.NotNull("qualifierExpression != null");
var referencePointer = reference.CreateTreeElementPointer();
var qualifierText = InsertQualifierAsArgument(
qualifierExpression, allMethods, argumentsCount, textControl, decoration, decorationText);
// TODO: mmm?
if (!hasMoreParameters && !decorationText.EndsWith(")", StringComparison.Ordinal))
{
caretMarker = caretMarker.DocumentRange.Shift(+qualifierText.Length).CreateRangeMarker();
}
// replace qualifier with type (predefined/user type)
var ownerType = allMethods[0].GetContainingType().NotNull("ownerType != null");
FixQualifierExpression(textControl, qualifierExpression, ownerType);
psiServices.CommitAllDocuments();
var newReference = referencePointer.GetTreeNode();
if (newReference != null)
{
var keyword = CSharpTypeFactory.GetTypeKeyword(ownerType.GetClrName());
if (keyword == null) // bind user type
{
var newQualifier = (IReferenceExpression)newReference.QualifierExpression;
if (newQualifier != null)
{
var elementInstance = lookupItem.GetDeclaredElement().NotNull("elementInstance != null");
newQualifier.Reference.BindTo(ownerType, elementInstance.Substitution);
}
range = newReference.NameIdentifier.GetDocumentRange().TextRange;
decoration = TextRange.InvalidRange;
}
// show parameter info when needed
if (hasMoreParameters)
{
var factory = solution.GetComponent <LookupItemsOwnerFactory>();
var lookupItemsOwner = factory.CreateLookupItemsOwner(textControl);
LookupUtil.ShowParameterInfo(solution, textControl, lookupItemsOwner);
}
}
TipsManager.Instance.FeatureIsUsed(
"Plugin.ControlFlow.PostfixTemplates.<static>", textControl.Document, solution);
});
}
