/// <summary>
/// Decodes a method from an LNode.
/// </summary>
/// <param name="data">The LNode to decode.</param>
/// <param name="state">The decoder to use.</param>
/// <returns>
/// A decoded method if the node can be decoded;
/// otherwise, <c>null</c>.
/// </returns>
public static IMethod Decode(LNode data, DecoderState state)
{
SimpleName name;
if (!FeedbackHelpers.AssertMinArgCount(data, 6, state.Log) ||
!state.AssertDecodeSimpleName(data.Args[0], out name))
{
return(null);
}
else
{
return(new IrMethod(data, state));
}
}
/// <inheritdoc/>
public override IType Decode(LNode data, DecoderState state)
{
if (data.Calls(pointerSymbol))
{
if (!FeedbackHelpers.AssertArgCount(data, 2, state.Log))
{
return(ErrorType.Instance);
}
var elemType = state.DecodeType(data.Args[0]);
PointerKind kind;
if (AssertDecodePointerKind(data.Args[1], state, out kind))
{
return(elemType.MakePointerType(kind));
}
else
{
return(ErrorType.Instance);
}
}
else if (data.Calls(genericParameterSymbol))
{
if (!FeedbackHelpers.AssertArgCount(data, 2, state.Log))
{
return(ErrorType.Instance);
}
IGenericMember parent;
SimpleName name;
if (state.AssertDecodeGenericMember(data.Args[0], out parent) &&
state.AssertDecodeSimpleName(data.Args[1], out name))
{
var types = state.TypeResolver.ResolveGenericParameters(parent, name);
if (AssertSingleChildType(types, data, state, "generic declaration"))
{
return(types[0]);
}
}
return(ErrorType.Instance);
}
else if (data.Calls(CodeSymbols.Of))
{
if (!FeedbackHelpers.AssertMinArgCount(data, 2, state.Log))
{
return(ErrorType.Instance);
}
var genericDecl = state.DecodeType(data.Args[0]);
var genericArgs = data.Args.Slice(1).EagerSelect <LNode, IType>(state.DecodeType);
int count = genericDecl.GenericParameters.Count;
if (count != genericArgs.Count)
{
FeedbackHelpers.LogSyntaxError(
state.Log,
data,
FeedbackHelpers.QuoteEven(
"type ",
FeedbackHelpers.Print(data.Args[0]),
" is instantiated with ",
genericArgs.Count.ToString(),
" arguments but has only ",
count.ToString(),
" parameters."));
return(ErrorType.Instance);
}
return(genericDecl.MakeGenericType(genericArgs));
}
else if (data.Calls(CodeSymbols.Dot))
{
if (!FeedbackHelpers.AssertArgCount(data, 2, state.Log))
{
return(ErrorType.Instance);
}
SimpleName childName;
if (!state.AssertDecodeSimpleName(data.Args[1], out childName))
{
return(ErrorType.Instance);
}
var parentType = state.DecodeType(data.Args[0]);
if (parentType == ErrorType.Instance)
{
// Make sure that we don't log an additional error
// just because the parent type was wrong.
return(ErrorType.Instance);
}
var childTypes = state.TypeResolver.ResolveNestedTypes(parentType, childName);
if (AssertSingleChildType(childTypes, data, state, "type"))
{
return(childTypes[0]);
}
else
{
return(ErrorType.Instance);
}
}
else
{
QualifiedName fullName;
if (state.AssertDecodeQualifiedName(data, out fullName))
{
var types = state.TypeResolver.ResolveTypes(fullName);
if (AssertSingleGlobalType(types, data, state))
{
return(types[0]);
}
else
{
return(ErrorType.Instance);
}
}
else
{
return(ErrorType.Instance);
}
}
}
/// <inheritdoc/>
public override ITypeMember Decode(LNode data, DecoderState state)
{
if (data.Calls(accessorSymbol))
{
if (!FeedbackHelpers.AssertArgCount(data, 2, state.Log) ||
!FeedbackHelpers.AssertIsId(data.Args[1], state.Log))
{
return(null);
}
var property = state.DecodeProperty(data.Args[0]);
if (property == null)
{
return(null);
}
else
{
var kindName = data.Args[1].Name.Name;
var accessor = property.Accessors.FirstOrDefault(
acc => accessorKindEncodings[acc.Kind] == kindName);
if (accessor == null)
{
FeedbackHelpers.LogSyntaxError(
state.Log,
data.Args[1],
Quotation.QuoteEvenInBold(
"property ",
FeedbackHelpers.Print(data.Args[0]),
" does not define a ",
kindName,
" accessor."));
}
return(accessor);
}
}
else if (data.Calls(CodeSymbols.Dot))
{
// Simple dot indicates a field.
IType parentType;
SimpleName name;
if (!AssertDecodeTypeAndName(data, state, out parentType, out name))
{
return(null);
}
var candidates = state.TypeMemberIndex
.GetAll(parentType, name)
.OfType <IField>()
.ToArray();
return(CheckSingleCandidate(
candidates,
data.Args[0],
data.Args[1],
"field",
state));
}
else if (data.CallsMin(CodeSymbols.IndexBracks, 1))
{
IType parentType;
SimpleName name;
if (!AssertDecodeTypeAndName(data.Args[0], state, out parentType, out name))
{
return(null);
}
var indexTypes = data.Args
.Slice(1)
.EagerSelect(state.DecodeType);
var candidates = state.TypeMemberIndex
.GetAll(parentType, name)
.OfType <IProperty>()
.Where(prop =>
prop.IndexerParameters
.Select(p => p.Type)
.SequenceEqual(indexTypes))
.ToArray();
return(CheckSingleCandidate(
candidates,
data.Args[0].Args[0],
data,
"property",
state));
}
else if (data.Calls(CodeSymbols.Lambda))
{
IType parentType;
SimpleName name;
if (!FeedbackHelpers.AssertArgCount(data, 2, state.Log) ||
!FeedbackHelpers.AssertIsCall(data.Args[0], state.Log) ||
!AssertDecodeTypeAndName(data.Args[0].Target, state, out parentType, out name))
{
return(null);
}
// TODO: implement generic parameter decoding, use generic
// parameters in resolution process.
var paramTypes = data.Args[0].Args
.EagerSelect(state.DecodeType);
var retType = state.DecodeType(data.Args[1]);
var candidates = state.TypeMemberIndex
.GetAll(parentType, name)
.OfType <IMethod>()
.Where(method =>
method.Parameters
.Select(p => p.Type)
.SequenceEqual(paramTypes) &&
object.Equals(
method.ReturnParameter.Type,
retType))
.ToArray();
return(CheckSingleCandidate(
candidates,
data.Args[0].Target.Args[0],
data,
"method",
state));
}
else if (data.Calls(CodeSymbols.Of))
{
if (!FeedbackHelpers.AssertMinArgCount(data, 1, state.Log))
{
return(null);
}
var func = state.DecodeMethod(data.Args[0]);
var args = data.Args.Slice(1).EagerSelect(state.DecodeType);
if (func.GenericParameters.Count == args.Count)
{
return(func.MakeGenericMethod(args));
}
else
{
state.Log.LogSyntaxError(
data,
Quotation.QuoteEvenInBold(
"generic arity mismatch; expected ",
func.GenericParameters.Count.ToString(),
" parameters but got ",
args.Count.ToString(),
"."));
return(null);
}
}
else
{
state.Log.LogSyntaxError(
data,
Quotation.QuoteEvenInBold(
"cannot interpret ",
FeedbackHelpers.Print(data),
" as a type member; expected a call to one of ",
accessorSymbol.Name, ", ",
CodeSymbols.Dot.Name, ", ",
CodeSymbols.IndexBracks.Name, ", ",
CodeSymbols.Of.Name, " or ",
CodeSymbols.Lambda.Name));
return(null);
}
}