private void ResolveReachabilityAnnotation(
CodeFile file,
IParameterNameSyntax syntax,
FixedSet <BindingSymbol> symbols)
{
switch (syntax)
{
default:
throw ExhaustiveMatch.Failed(syntax);
case INamedParameterNameSyntax syn:
{
var referencedSymbol = symbols.OfType <VariableSymbol>().SingleOrDefault(s => s.Name == syn.Name);
syn.ReferencedSymbol.Fulfill(referencedSymbol);
if (referencedSymbol is null)
{
diagnostics.Add(NameBindingError.CouldNotBindParameterName(file, syn.Span));
}
}
break;
case ISelfParameterNameSyntax syn:
{
var referencedSymbol = symbols.OfType <SelfParameterSymbol>().SingleOrDefault();
syn.ReferencedSymbol.Fulfill(referencedSymbol);
if (referencedSymbol is null)
{
diagnostics.Add(NameBindingError.CouldNotBindParameterName(file, syn.Span));
}
}
break;
}
}
private DataType InferConstructorCallType(NewObjectExpressionSyntax expression)
{
var argumentTypes = expression.Arguments.Select(InferArgumentType).ToFixedList();
// TODO handle named constructors here
var constructedType = (ObjectType)CheckAndEvaluateTypeExpression(expression.Constructor);
var typeSymbol = GetSymbolForType(constructedType);
var constructors = typeSymbol.ChildSymbols[SpecialName.New];
constructors = ResolveOverload(constructors, null, argumentTypes);
switch (constructors.Count)
{
case 0:
diagnostics.Add(NameBindingError.CouldNotBindConstructor(file, expression.Span));
expression.ConstructorSymbol = UnknownSymbol.Instance;
expression.ConstructorType = DataType.Unknown;
break;
case 1:
var constructorSymbol = constructors.Single();
expression.ConstructorSymbol = constructorSymbol;
var constructorType = constructorSymbol.Type;
expression.ConstructorType = constructorType;
if (constructorType is FunctionType functionType)
{
foreach (var(arg, type) in expression.Arguments.Zip(functionType.ParameterTypes))
{
InsertImplicitConversionIfNeeded(ref arg.Value, type);
CheckArgumentTypeCompatibility(type, arg);
}
}
break;
default:
diagnostics.Add(NameBindingError.AmbiguousConstructor(file, expression.Span));
expression.ConstructorSymbol = UnknownSymbol.Instance;
expression.ConstructorType = DataType.Unknown;
break;
}
return(expression.Type = constructedType.WithLifetime(Lifetime.Owned));
}
private DataType AssignReferencedSymbolAndType(
NameSyntax identifier,
FixedList <ISymbol> memberSymbols)
{
switch (memberSymbols.Count)
{
case 0:
diagnostics.Add(NameBindingError.CouldNotBindMember(file, identifier.Span));
identifier.ReferencedSymbol = UnknownSymbol.Instance;
return(identifier.Type = DataType.Unknown);
case 1:
var memberSymbol = memberSymbols.Single();
identifier.ReferencedSymbol = memberSymbol;
return(identifier.Type = memberSymbol.Type);
default:
diagnostics.Add(NameBindingError.AmbiguousName(file, identifier.Span));
identifier.ReferencedSymbol = UnknownSymbol.Instance;
return(identifier.Type = DataType.Unknown);
}
}
private DataType InferExpressionType(ExpressionSyntax expression)
{
if (expression == null)
{
return(DataType.Unknown);
}
switch (expression)
{
case ReturnExpressionSyntax returnExpression:
if (returnExpression.ReturnValue != null)
{
InferExpressionType(returnExpression.ReturnValue);
if (returnType != null) // TODO report an error
{
InsertImplicitConversionIfNeeded(ref returnExpression.ReturnValue, returnType);
var type = returnExpression.ReturnValue.Type;
if (!IsAssignableFrom(returnType, type))
{
diagnostics.Add(TypeError.CannotConvert(file,
returnExpression.ReturnValue, type, returnType));
}
}
}
else
{
// TODO a void or never function shouldn't have this
}
return(expression.Type = DataType.Never);
case IntegerLiteralExpressionSyntax integerLiteral:
return(expression.Type = new IntegerConstantType(integerLiteral.Value));
case StringLiteralExpressionSyntax _:
return(expression.Type = DataType.StringConstant);
case BoolLiteralExpressionSyntax _:
return(expression.Type = DataType.Bool);
case BinaryExpressionSyntax binaryOperatorExpression:
return(InferBinaryExpressionType(binaryOperatorExpression));
case IdentifierNameSyntax identifierName:
{
var symbols = identifierName.LookupInContainingScope();
DataType type;
switch (symbols.Count)
{
case 0:
diagnostics.Add(NameBindingError.CouldNotBindName(file, identifierName.Span));
identifierName.ReferencedSymbol = UnknownSymbol.Instance;
type = DataType.Unknown;
break;
case 1:
identifierName.ReferencedSymbol = symbols.Single();
type = symbols.Single().Type;
break;
default:
diagnostics.Add(NameBindingError.AmbiguousName(file, identifierName.Span));
identifierName.ReferencedSymbol = UnknownSymbol.Instance;
type = DataType.Unknown;
break;
}
return(identifierName.Type = type);
}
case UnaryExpressionSyntax unaryOperatorExpression:
return(InferUnaryExpressionType(unaryOperatorExpression));
case ReferenceLifetimeSyntax lifetimeType:
InferExpressionType(lifetimeType.ReferentTypeExpression);
if (!IsType(lifetimeType.ReferentTypeExpression.Type))
{
diagnostics.Add(TypeError.MustBeATypeExpression(file, lifetimeType.ReferentTypeExpression.Span));
}
return(expression.Type = DataType.Type);
case BlockSyntax blockExpression:
foreach (var statement in blockExpression.Statements)
{
ResolveTypesInStatement(statement);
}
return(expression.Type = DataType.Void); // TODO assign the correct type to the block
case NewObjectExpressionSyntax newObjectExpression:
return(InferConstructorCallType(newObjectExpression));
case PlacementInitExpressionSyntax placementInitExpression:
foreach (var argument in placementInitExpression.Arguments)
{
InferArgumentType(argument);
}
// TODO verify argument types against called function
return(placementInitExpression.Type = CheckAndEvaluateTypeExpression(placementInitExpression.Initializer));
case ForeachExpressionSyntax foreachExpression:
foreachExpression.Type =
CheckAndEvaluateTypeExpression(foreachExpression.TypeExpression);
InferExpressionType(foreachExpression.InExpression);
// TODO check the break types
InferExpressionType(foreachExpression.Block);
// TODO assign correct type to the expression
return(expression.Type = DataType.Void);
case WhileExpressionSyntax whileExpression:
CheckExpressionType(whileExpression.Condition, DataType.Bool);
InferExpressionType(whileExpression.Block);
// TODO assign correct type to the expression
return(expression.Type = DataType.Void);
case LoopExpressionSyntax loopExpression:
InferExpressionType(loopExpression.Block);
// TODO assign correct type to the expression
return(expression.Type = DataType.Void);
case InvocationSyntax invocation:
return(InferInvocationType(invocation));
case GenericNameSyntax genericName:
{
foreach (var argument in genericName.Arguments)
{
InferExpressionType(argument.Value);
}
genericName.NameType.BeginFulfilling();
var nameType = InferNameType(genericName);
// TODO check that argument types match function type
genericName.NameType.Fulfill(nameType);
switch (nameType)
{
case MetaFunctionType metaFunctionType:
return(genericName.Type = metaFunctionType.ResultType);
case UnknownType _:
return(genericName.Type = DataType.Unknown);
default:
throw NonExhaustiveMatchException.For(genericName.NameType);
}
}
case RefTypeSyntax refType:
CheckAndEvaluateTypeExpression(refType.ReferencedType);
return(refType.Type = DataType.Type);
case UnsafeExpressionSyntax unsafeExpression:
InferExpressionType(unsafeExpression.Expression);
return(unsafeExpression.Type = unsafeExpression.Expression.Type);
case MutableExpressionSyntax mutableExpression:
{
var expressionType = InferExpressionType(mutableExpression.Expression);
DataType type;
if (expressionType is Metatype)
{
type = DataType.Type; // It names/describes a type
}
else
{
// TODO check that the type actually is mutable so we can mutably borrow it
type = expressionType;
}
return(mutableExpression.Type = type);
}
case IfExpressionSyntax ifExpression:
CheckExpressionType(ifExpression.Condition, DataType.Bool);
InferExpressionType(ifExpression.ThenBlock);
InferExpressionType(ifExpression.ElseClause);
// TODO assign a type to the expression
return(ifExpression.Type = DataType.Void);
case ResultExpressionSyntax resultExpression:
InferExpressionType(resultExpression.Expression);
return(resultExpression.Type = DataType.Never);
case MemberAccessExpressionSyntax memberAccess:
return(InferMemberAccessType(memberAccess));
case BreakExpressionSyntax breakExpression:
InferExpressionType(breakExpression.Value);
return(breakExpression.Type = DataType.Never);
case AssignmentExpressionSyntax assignmentExpression:
var left = InferExpressionType(assignmentExpression.LeftOperand);
InferExpressionType(assignmentExpression.RightOperand);
InsertImplicitConversionIfNeeded(ref assignmentExpression.RightOperand, left);
var right = assignmentExpression.RightOperand.Type;
if (!IsAssignableFrom(left, right))
{
diagnostics.Add(TypeError.CannotConvert(file, assignmentExpression.RightOperand, right, left));
}
return(assignmentExpression.Type = DataType.Void);
case SelfExpressionSyntax _:
return(selfType ?? DataType.Unknown);
case MoveExpressionSyntax moveExpression:
{
var type = InferExpressionType(moveExpression.Expression);
if (type is ReferenceType referenceType && !referenceType.IsOwned)
{
diagnostics.Add(TypeError.CannotMoveBorrowedValue(file, moveExpression));
type = referenceType.WithLifetime(Lifetime.Owned);
}
return(moveExpression.Type = type);
}
default:
throw NonExhaustiveMatchException.For(expression);
}
}
public DataType?Evaluate(ITypeSyntax?typeSyntax)
{
switch (typeSyntax)
{
default:
throw ExhaustiveMatch.Failed(typeSyntax);
case null:
return(null);
case ITypeNameSyntax typeName:
{
var symbolPromises = typeName.LookupInContainingScope().ToFixedList();
switch (symbolPromises.Count)
{
case 0:
diagnostics.Add(NameBindingError.CouldNotBindName(file, typeName.Span));
typeName.ReferencedSymbol.Fulfill(null);
typeName.NamedType = DataType.Unknown;
break;
case 1:
var symbol = symbolPromises.Single().Result;
typeName.ReferencedSymbol.Fulfill(symbol);
typeName.NamedType = symbol.DeclaresDataType;
break;
default:
diagnostics.Add(NameBindingError.AmbiguousName(file, typeName.Span));
typeName.ReferencedSymbol.Fulfill(null);
typeName.NamedType = DataType.Unknown;
break;
}
break;
}
case ICapabilityTypeSyntax referenceCapability:
{
var type = Evaluate(referenceCapability.ReferentType);
if (type == DataType.Unknown)
{
return(DataType.Unknown);
}
if (type is ReferenceType referenceType)
{
referenceCapability.NamedType = referenceType.To(referenceCapability.Capability);
}
else
{
referenceCapability.NamedType = DataType.Unknown;
}
break;
}
case IOptionalTypeSyntax optionalType:
{
var referent = Evaluate(optionalType.Referent);
return(optionalType.NamedType = new OptionalType(referent));
}
}
return(typeSyntax.NamedType ?? throw new InvalidOperationException());
}
