private static IDeclaredElement GetActivePatternCaseElement(IPsiModule psiModule,
IFSharpReferenceOwner referenceExpression, FSharpActivePatternCase patternCase)
{
var pattern = patternCase.Group;
var entity = pattern.DeclaringEntity?.Value;
if (entity == null)
{
return(GetActivePatternCaseElement(patternCase, psiModule, referenceExpression));
}
var typeElement = GetTypeElement(entity, psiModule);
var patternName = pattern.Name?.Value;
if (typeElement == null || patternName == null)
{
return(null);
}
if (typeElement.Module.ContainingProjectModule is IProject)
{
return(GetActivePatternCaseElement(patternCase, psiModule, referenceExpression));
}
var patternMfv = entity.MembersFunctionsAndValues.FirstOrDefault(mfv => mfv.LogicalName == patternName);
var patternCompiledName = patternMfv?.CompiledName ?? patternCase.Name;
if (typeElement.EnumerateMembers(patternCompiledName, true).FirstOrDefault() is IMethod method)
{
return(new CompiledActivePatternCase(method, patternCase.Name, patternCase.Index));
}
return(null);
}
private static IDeclaredElement GetLocalValueDeclaredElement(FSharpMemberOrFunctionOrValue mfv,
IFSharpReferenceOwner referenceExpression)
{
var declaration = FindNode <IFSharpDeclaration>(mfv.DeclarationLocation, referenceExpression);
if (declaration is IFSharpLocalDeclaration localDeclaration)
{
return(localDeclaration);
}
return(declaration is IFSharpPattern
? declaration.DeclaredElement
: null);
}
private static ITypeParameter GetTypeParameter([NotNull] FSharpGenericParameter parameter,
[CanBeNull] IFSharpReferenceOwner referenceOwnerToken = null)
{
var containingMemberDeclaration = referenceOwnerToken?.GetContainingNode <ITypeMemberDeclaration>();
if (!(containingMemberDeclaration?.DeclaredElement is IFSharpTypeParametersOwner containingMember))
{
return(null);
}
var parameterName = parameter.Name;
var typeParameter = containingMember.AllTypeParameters.FirstOrDefault(param => param.ShortName == parameterName);
return(typeParameter);
}
public static IList <IArgument> CalculateParameterArguments(this IFSharpReferenceOwner referenceOwner,
IEnumerable <IFSharpExpression> appliedExpressions)
{
if (!(referenceOwner.Reference.GetFSharpSymbol() is FSharpMemberOrFunctionOrValue mfv))
{
return(EmptyList <IArgument> .Instance);
}
var paramGroups = mfv.CurriedParameterGroups;
var isVoidReturn = paramGroups.Count == 1 && paramGroups[0].Count == 1 && paramGroups[0][0].Type.IsUnit;
if (isVoidReturn)
{
return(EmptyArray <IArgument> .Instance);
}
return(paramGroups
.Zip(appliedExpressions, (paramGroup, argExpr) => (paramGroup, argExpr.IgnoreInnerParens()))
.SelectMany(pair =>
{
var(paramGroup, argExpr) = pair;
// e.g. F# extension methods with 0 parameters
if (paramGroup.Count == 0)
{
return EmptyList <IArgument> .Instance;
}
if (paramGroup.Count == 1)
{
return new[] { argExpr as IArgument }
}
;
var tupleExprs = argExpr is ITupleExpr tupleExpr
? (IReadOnlyList <IFSharpExpression>)tupleExpr.Expressions
: EmptyList <IFSharpExpression> .Instance;
return Enumerable.Range(0, paramGroup.Count)
.Select(i => i < tupleExprs.Count ? tupleExprs[i] as IArgument : null);
}).ToList());
}
private static IFSharpDeclaration GetActivePatternDeclaration([NotNull] FSharpActivePatternCase activePatternCase,
[NotNull] IPsiModule psiModule, IFSharpReferenceOwner referenceOwnerToken)
{
var activePattern = activePatternCase.Group;
var declaringEntity = activePattern.DeclaringEntity?.Value;
if (declaringEntity != null)
{
var patternName = activePattern.PatternName();
var typeElement = GetTypeElement(declaringEntity, psiModule);
var patternElement = typeElement.EnumerateMembers(patternName, true).FirstOrDefault();
return(patternElement?.GetDeclarations().FirstOrDefault() as IFSharpDeclaration);
}
var patternId = FindNode <IActivePatternId>(activePatternCase.DeclarationLocation, referenceOwnerToken);
return(patternId?.GetContainingNode <IFSharpDeclaration>());
}
public static IDeclaredElement GetActivePatternCaseElement([NotNull] FSharpActivePatternCase activePatternCase,
[NotNull] IPsiModule psiModule, [CanBeNull] IFSharpReferenceOwner referenceOwnerToken)
{
var declaration = GetActivePatternDeclaration(activePatternCase, psiModule, referenceOwnerToken);
return(declaration?.GetActivePatternByIndex(activePatternCase.Index));
}
public static IDeclaredElement GetDeclaredElement([CanBeNull] this FSharpSymbol symbol,
[NotNull] IPsiModule psiModule, [CanBeNull] IFSharpReferenceOwner referenceExpression = null)
{
if (symbol == null)
{
return(null);
}
if (symbol is FSharpEntity entity)
{
if (entity.IsUnresolved)
{
return(null);
}
if (entity.IsNamespace)
{
return(GetDeclaredNamespace(entity, psiModule));
}
return(GetTypeElement(entity, psiModule));
}
if (symbol is FSharpMemberOrFunctionOrValue mfv)
{
if (mfv.IsUnresolved)
{
return(null);
}
return(mfv.IsModuleValueOrMember
? GetTypeMember(mfv, psiModule)
: GetLocalValueDeclaredElement(mfv, referenceExpression));
}
if (symbol is FSharpUnionCase unionCase)
{
return(GetDeclaredElement(unionCase, psiModule));
}
if (symbol is FSharpField field)
{
if (field.IsAnonRecordField && referenceExpression != null)
{
return(new FSharpAnonRecordFieldProperty(referenceExpression.Reference));
}
if (field.IsUnionCaseField && field.DeclaringUnionCase?.Value is { } fieldUnionCase)
{
var unionEntity = fieldUnionCase.ReturnType.TypeDefinition;
var fieldOwnerTypeElement =
unionEntity.UnionCases.Count > 1 && !unionEntity.IsValueType
? GetDeclaredElement(fieldUnionCase, psiModule, true) as ITypeElement
: GetTypeElement(unionEntity, psiModule);
return(fieldOwnerTypeElement?.EnumerateMembers(field.Name, true).FirstOrDefault());
}
if (!field.IsUnresolved && field.DeclaringEntity?.Value is { } fieldEntity)
{
return(GetTypeElement(fieldEntity, psiModule)?.EnumerateMembers(field.Name, true).FirstOrDefault());
}
}
if (symbol is FSharpActivePatternCase patternCase)
{
return(GetActivePatternCaseElement(psiModule, referenceExpression, patternCase));
}
if (symbol is FSharpGenericParameter genericParameter)
{
return(GetTypeParameter(genericParameter, referenceExpression));
}
if (symbol is FSharpParameter parameter && referenceExpression != null)
{
return(parameter.GetOwner(referenceExpression.Reference)); // todo: map to parameter
}
return(null);
}
public static IDeclaredElement GetDeclaredElement([CanBeNull] this FSharpSymbol symbol,
[NotNull] IPsiModule psiModule, [CanBeNull] IFSharpReferenceOwner referenceExpression = null)
{
if (symbol == null)
{
return(null);
}
if (symbol is FSharpEntity entity)
{
if (entity.IsUnresolved)
{
return(null);
}
if (entity.IsNamespace)
{
return(GetDeclaredNamespace(entity, psiModule));
}
return(GetTypeElement(entity, psiModule));
}
if (symbol is FSharpMemberOrFunctionOrValue mfv)
{
if (mfv.IsUnresolved)
{
return(null);
}
if (!mfv.IsModuleValueOrMember)
{
var declaration = FindNode <IFSharpDeclaration>(mfv.DeclarationLocation, referenceExpression);
if (declaration is IFSharpLocalDeclaration localDeclaration)
{
return(localDeclaration);
}
return(declaration is ISynPat
? declaration.DeclaredElement
: null);
}
var memberEntity = mfv.IsModuleValueOrMember ? mfv.DeclaringEntity : null;
if (memberEntity == null)
{
return(null);
}
if (mfv.IsConstructor && mfv.DeclaringEntity?.Value is FSharpEntity ctorEntity && ctorEntity.IsProvided)
{
return(GetDeclaredElement(memberEntity.Value, psiModule, referenceExpression));
}
var typeElement = GetTypeElement(memberEntity.Value, psiModule);
if (typeElement == null)
{
return(null);
}
var mfvCompiledName = mfv.GetMfvCompiledName();
var members = mfv.IsConstructor
? typeElement.Constructors.AsList <ITypeMember>()
: typeElement.EnumerateMembers(mfvCompiledName, true).AsList();
switch (members.Count)
{
case 0:
return(null);
case 1:
return(members[0]);
}
var mfvXmlDocId = GetXmlDocId(mfv);
return(members.FirstOrDefault(member =>
// todo: Fix signature for extension properties
member is IFSharpMember fsMember && fsMember.Mfv?.XmlDocSig == mfvXmlDocId ||
member.XMLDocId == mfvXmlDocId));
}
if (symbol is FSharpUnionCase unionCase)
{
if (unionCase.IsUnresolved)
{
return(null);
}
var unionTypeElement = GetTypeElement(unionCase.ReturnType.TypeDefinition, psiModule);
if (unionTypeElement == null)
{
return(null);
}
var caseCompiledName = unionCase.CompiledName;
var caseMember = unionTypeElement.GetMembers().FirstOrDefault(m =>
{
var shortName = m.ShortName;
return(shortName == caseCompiledName || shortName == "New" + caseCompiledName);
});
if (caseMember != null)
{
return(caseMember);
}
var unionClrName = unionTypeElement.GetClrName();
var caseDeclaredType = TypeFactory.CreateTypeByCLRName(unionClrName + "+" + caseCompiledName, psiModule);
return(caseDeclaredType.GetTypeElement());
}
if (symbol is FSharpField field)
{
if (field.IsAnonRecordField)
{
return(new FSharpAnonRecordFieldProperty(referenceExpression.Reference));
}
if (field.IsUnionCaseField && field.DeclaringUnionCase?.Value is var fieldUnionCase)
{
var unionCaseTypeElement = GetDeclaredElement(fieldUnionCase, psiModule, referenceExpression) as ITypeElement;
return(unionCaseTypeElement?.EnumerateMembers(field.Name, true).FirstOrDefault());
}
if (!field.IsUnresolved && field.DeclaringEntity?.Value is FSharpEntity fieldEntity)
{
return(GetTypeElement(fieldEntity, psiModule)?.EnumerateMembers(field.Name, true).FirstOrDefault());
}
}
if (symbol is FSharpActivePatternCase patternCase)
{
return(GetActivePatternCaseElement(psiModule, referenceExpression, patternCase));
}
if (symbol is FSharpGenericParameter genericParameter)
{
return(GetTypeParameter(genericParameter, referenceExpression));
}
if (symbol is FSharpParameter parameter && referenceExpression != null)
{
return(parameter.GetOwner(referenceExpression.Reference)); // todo: map to parameter
}
return(null);
}
public static IFSharpReferenceOwner GetByQualifier([CanBeNull] IFSharpReferenceOwner param) => ReferenceExprNavigator.GetByQualifier(param as ISynExpr) ?? (IFSharpReferenceOwner)ReferenceNameNavigator.GetByQualifier(param as IReferenceName) ?? TypeExtensionDeclarationNavigator.GetByQualifierReferenceName(param as IReferenceName);
public ReferenceExpressionTypeReference([NotNull] IFSharpReferenceOwner owner) : base(owner)
{
}
public TypeExtensionReference([NotNull] IFSharpReferenceOwner owner) : base(owner)
{
}
private static IDeclaredElement GetFieldDeclaredElement([NotNull] IReference reference,
[NotNull] FSharpUnionCase unionCase, [NotNull] IFSharpReferenceOwner referenceOwner)
{
var field = unionCase.UnionCaseFields.FirstOrDefault(f => f.Name == reference.GetName());
return(field?.GetDeclaredElement(referenceOwner.GetPsiModule(), referenceOwner));
}
public CtorReference([NotNull] IFSharpReferenceOwner owner) : base(owner)
{
}
