IEnumerable <CodeAction> GetActionsForExtensionMethodInvocation(RefactoringContext context, InvocationExpression invocation)
{
var rr = context.Resolve(invocation) as UnknownMethodResolveResult;
if (rr == null)
{
return(EmptyList <CodeAction> .Instance);
}
var lookup = new MemberLookup(null, context.Compilation.MainAssembly);
HashSet <string> namespaces = new HashSet <string>();
List <CodeAction> result = new List <CodeAction>();
foreach (var typeDefinition in context.Compilation.GetAllTypeDefinitions())
{
if (!(typeDefinition.HasExtensionMethods && lookup.IsAccessible(typeDefinition, false)))
{
continue;
}
foreach (var method in typeDefinition.Methods.Where(m => m.IsExtensionMethod && m.Name == rr.MemberName))
{
IType[] inferredTypes;
if (AlResolver.IsEligibleExtensionMethod(rr.TargetType, method, true, out inferredTypes))
{
// avoid offering the same namespace twice
if (namespaces.Add(typeDefinition.Namespace))
{
result.Add(NewUsingAction(context, invocation, typeDefinition.Namespace));
}
break; // continue with the next type
}
}
}
return(result);
}
public AlCompletionDataFactory(AlCompletionContext completionContext, AlResolver contextAtCaret)
{
Debug.Assert(completionContext != null);
Debug.Assert(contextAtCaret != null);
this.completionContext = completionContext;
this.contextAtCaret = contextAtCaret;
this.builder = new TypeSystemAstBuilder(contextAtCaret);
}
public IList <ControlFlowNode> BuildControlFlowGraph(Statement statement, CancellationToken cancellationToken = default(CancellationToken))
{
if (statement == null)
{
throw new ArgumentNullException("statement");
}
AlResolver r = new AlResolver(MinimalCorlib.Instance.CreateCompilation());
return(BuildControlFlowGraph(statement, new AlAstResolver(r, statement), cancellationToken));
}
public PartialCompletionData(int declarationBegin, IMember m, AlResolver contextAtCaret)
: base(m)
{
this.declarationBegin = declarationBegin;
this.contextAtCaret = contextAtCaret;
var ambience = new AlAmbience();
ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList | ConversionFlags.ShowParameterList | ConversionFlags.ShowParameterNames;
this.CompletionText = ambience.ConvertSymbol(m);
}
bool AreEqualConstants(ResolveResult c1, ResolveResult c2)
{
if (c1 == null || c2 == null || !c1.IsCompileTimeConstant || !c2.IsCompileTimeConstant)
{
return(false);
}
AlResolver r = new AlResolver(typeResolveContext);
ResolveResult c = r.ResolveBinaryOperator(BinaryOperatorType.Equality, c1, c2);
return(c.IsCompileTimeConstant && (c.ConstantValue as bool?) == true);
}
public ImportCompletionData(ITypeDefinition typeDef, AlResolver contextAtCaret, bool useFullName)
: base(typeDef)
{
this.Description = "include " + typeDef.Namespace + ";";
if (useFullName)
{
var astBuilder = new TypeSystemAstBuilder(contextAtCaret);
insertionText = astBuilder.ConvertType(typeDef).ToString();
}
else
{
insertionText = typeDef.Name;
insertUsing = typeDef.Namespace;
}
}
public ICompletionData AddEnumMembers(IType resolvedType, AlResolver state)
{
if (addedEnums.Contains(resolvedType))
{
return(null);
}
addedEnums.Add(resolvedType);
var result = AddType(resolvedType, true);
foreach (var field in resolvedType.GetFields())
{
if (field.IsPublic && (field.IsConst || field.IsStatic))
{
Result.Add(Factory.CreateMemberCompletionData(resolvedType, field));
}
}
return(result);
}
public ResolveResult ResolveSnippet(ParseInformation parseInfo, TextLocation location, string codeSnippet, ICompilation compilation, CancellationToken cancellationToken)
{
var csParseInfo = parseInfo as AlFullParseInformation;
if (csParseInfo == null)
throw new ArgumentException("Parse info does not have SyntaxTree");
AlAstResolver contextResolver = new AlAstResolver(compilation, csParseInfo.SyntaxTree, csParseInfo.UnresolvedFile);
var node = csParseInfo.SyntaxTree.GetNodeAt(location);
AlResolver context;
if (node != null)
context = contextResolver.GetResolverStateAfter(node, cancellationToken);
else
context = new AlResolver(compilation);
AlParser parser = new AlParser();
var expr = parser.ParseExpression(codeSnippet);
if (parser.HasErrors)
return new ErrorResolveResult(SpecialType.UnknownType, PrintErrorsAsString(parser.Errors), TextLocation.Empty);
AlAstResolver snippetResolver = new AlAstResolver(context, expr);
return snippetResolver.Resolve(expr, cancellationToken);
}
static bool IsNameUsed(AlResolver resolver, QueryExpression query, string name)
{
if (resolver.ResolveSimpleName(name, new List <IType>()) is LocalResolveResult)
{
return(true);
}
if (query.Ancestors.OfType <VariableInitializer>().Any(variable => variable.Name == name))
{
return(true);
}
if (query.Ancestors.OfType <BlockStatement>()
.Any(blockStatement => DeclaresLocalVariable(blockStatement, name)))
{
return(true);
}
return(query.Descendants.OfType <Identifier> ().Any(identifier => identifier.Name == name));
}
public OverrideEqualsGetHashCodeCompletionData(int declarationBegin, IMember m, AlResolver contextAtCaret)
: base(declarationBegin, m, contextAtCaret)
{
}
public OverrideToStringCompletionData(int declarationBegin, IMember m, AlResolver contextAtCaret)
: base(declarationBegin, m, contextAtCaret)
{
}
public ExpressionResolveResult(ResolveResult item1, AlResolver item2, AlAstResolver item3)
{
this.Result = item1;
this.Resolver = item2;
this.AstResolver = item3;
}
public AlAstResolver GetResolver(AlResolver resolver, AstNode rootNode)
{
return(new AlAstResolver(resolver, rootNode, unresolvedFile));
}
public EventCreationCompletionData(string handlerName, IType delegateType, IEvent evt, string parameterList, IUnresolvedMember callingMember, IUnresolvedTypeDefinition declaringType, AlResolver contextAtCaret)
{
if (string.IsNullOrEmpty(handlerName))
{
handlerName = (evt != null ? evt.Name : "Handle");
}
this.handlerName = handlerName;
this.DisplayText = StringParser.Parse("${res:AlBinding.Refactoring.EventCreation.EventHandlerText}", new[] { new StringTagPair("HandlerName", handlerName) });
this.delegateTypeReference = delegateType.ToTypeReference();
this.isStatic = callingMember != null && callingMember.IsStatic;
}
