Upstream gleam-lang/gleam state of the touched files before fe0ae5310a
This commit is contained in:
upstream committed
1 parent
88fec07fd0
commit
305f0f4ec3
3 files changed
+1201
No files matched your search
@@ -0,0 +1,675 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// SPDX-FileCopyrightText: 2020 The Gleam contributors
|
||||
|
||||
use super::*;
|
||||
use crate::analyse::Inferred;
|
||||
use crate::type_::{FieldMap, HasType};
|
||||
|
||||
pub type TypedConstant = Constant<Arc<Type>>;
|
||||
pub type UntypedConstant = Constant<()>;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
||||
pub enum Constant<T> {
|
||||
Int {
|
||||
location: SrcSpan,
|
||||
value: EcoString,
|
||||
int_value: BigInt,
|
||||
},
|
||||
|
||||
Float {
|
||||
location: SrcSpan,
|
||||
value: EcoString,
|
||||
float_value: LiteralFloatValue,
|
||||
},
|
||||
|
||||
String {
|
||||
location: SrcSpan,
|
||||
value: EcoString,
|
||||
},
|
||||
|
||||
Tuple {
|
||||
location: SrcSpan,
|
||||
elements: Vec<Self>,
|
||||
type_: T,
|
||||
},
|
||||
|
||||
List {
|
||||
location: SrcSpan,
|
||||
elements: Vec<Self>,
|
||||
type_: T,
|
||||
tail: Option<Box<Self>>,
|
||||
},
|
||||
|
||||
Record {
|
||||
location: SrcSpan,
|
||||
arguments_start_position: u32,
|
||||
module: Option<(EcoString, SrcSpan)>,
|
||||
name: EcoString,
|
||||
/// These are the arguments used when calling the record.
|
||||
/// If the record is not being called to build a value, then this will
|
||||
/// be `None`. A couple of examples:
|
||||
/// ```gleam
|
||||
/// pub const a = Wibble
|
||||
/// // arguments: None
|
||||
///
|
||||
/// pub const b = Wibble()
|
||||
/// // arguments: Some(vec![])
|
||||
///
|
||||
/// pub const c = Wibble(1, 2)
|
||||
/// // arguments: Some(vec![1, 2])
|
||||
/// ```
|
||||
arguments: Option<Vec<CallArg<Self>>>,
|
||||
type_: T,
|
||||
field_map: Inferred<FieldMap>,
|
||||
record_constructor: Option<Box<ValueConstructor>>,
|
||||
},
|
||||
|
||||
RecordUpdate {
|
||||
location: SrcSpan,
|
||||
constructor_location: SrcSpan,
|
||||
module: Option<(EcoString, SrcSpan)>,
|
||||
name: EcoString,
|
||||
record: RecordBeingUpdated<Self>,
|
||||
arguments: Vec<RecordUpdateArg<Self>>,
|
||||
type_: T,
|
||||
field_map: Inferred<FieldMap>,
|
||||
},
|
||||
|
||||
BitArray {
|
||||
location: SrcSpan,
|
||||
segments: Vec<BitArraySegment<Self, T>>,
|
||||
},
|
||||
|
||||
Var {
|
||||
location: SrcSpan,
|
||||
module: Option<(EcoString, SrcSpan)>,
|
||||
name: EcoString,
|
||||
constructor: Option<Box<ValueConstructor>>,
|
||||
type_: T,
|
||||
},
|
||||
|
||||
/// A constant binary operation.
|
||||
/// Most binops are not supported in constants yet, however we parse them
|
||||
/// and produce an error during type analysis rather than during parsing so
|
||||
/// we can get better error messages and language server code actions.
|
||||
BinaryOperator {
|
||||
location: SrcSpan,
|
||||
operator_start: u32,
|
||||
operator: BinOp,
|
||||
left: Box<Self>,
|
||||
right: Box<Self>,
|
||||
type_: T,
|
||||
},
|
||||
|
||||
/// A placeholder constant used to allow module analysis to continue
|
||||
/// even when there are type errors. Should never end up in generated code.
|
||||
Invalid {
|
||||
location: SrcSpan,
|
||||
type_: T,
|
||||
/// Extra information about the invalid expression, useful for providing
|
||||
/// addition help or information, such as code actions to fix invalid
|
||||
/// states.
|
||||
extra_information: Option<InvalidExpression>,
|
||||
},
|
||||
|
||||
Todo {
|
||||
location: SrcSpan,
|
||||
type_: T,
|
||||
message: Option<Box<Self>>,
|
||||
},
|
||||
}
|
||||
|
||||
impl<T> Constant<T> {
|
||||
pub fn bin_op_precedence(&self) -> u8 {
|
||||
match self {
|
||||
Self::BinaryOperator { operator, .. } => operator.precedence(),
|
||||
Self::Int { .. }
|
||||
| Self::Float { .. }
|
||||
| Self::String { .. }
|
||||
| Self::Var { .. }
|
||||
| Self::List { .. }
|
||||
| Self::Tuple { .. }
|
||||
| Self::Todo { .. }
|
||||
| Self::BitArray { .. }
|
||||
| Self::Invalid { .. }
|
||||
| Self::Record { .. }
|
||||
| Self::RecordUpdate { .. } => u8::MAX,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn bin_op_name(&self) -> Option<BinOp> {
|
||||
if let Self::BinaryOperator { operator, .. } = self {
|
||||
Some(*operator)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_tuple(&self) -> bool {
|
||||
match self {
|
||||
Constant::Tuple { .. } => true,
|
||||
|
||||
Constant::Int { .. }
|
||||
| Constant::Float { .. }
|
||||
| Constant::String { .. }
|
||||
| Constant::List { .. }
|
||||
| Constant::Record { .. }
|
||||
| Constant::RecordUpdate { .. }
|
||||
| Constant::BitArray { .. }
|
||||
| Constant::Var { .. }
|
||||
| Constant::BinaryOperator { .. }
|
||||
| Constant::Invalid { .. }
|
||||
| Constant::Todo { .. } => false,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_binop(&self) -> bool {
|
||||
match self {
|
||||
Constant::BinaryOperator { .. } => true,
|
||||
|
||||
Constant::Tuple { .. }
|
||||
| Constant::Int { .. }
|
||||
| Constant::Float { .. }
|
||||
| Constant::String { .. }
|
||||
| Constant::List { .. }
|
||||
| Constant::Record { .. }
|
||||
| Constant::RecordUpdate { .. }
|
||||
| Constant::BitArray { .. }
|
||||
| Constant::Var { .. }
|
||||
| Constant::Invalid { .. }
|
||||
| Constant::Todo { .. } => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TypedConstant {
|
||||
pub fn type_(&self) -> Arc<Type> {
|
||||
match self {
|
||||
Constant::Int { .. } => type_::int(),
|
||||
Constant::Float { .. } => type_::float(),
|
||||
Constant::String { .. } => type_::string(),
|
||||
Constant::BitArray { .. } => type_::bit_array(),
|
||||
|
||||
Constant::List { type_, .. }
|
||||
| Constant::BinaryOperator { type_, .. }
|
||||
| Constant::Tuple { type_, .. }
|
||||
| Constant::Record { type_, .. }
|
||||
| Constant::RecordUpdate { type_, .. }
|
||||
| Constant::Var { type_, .. }
|
||||
| Constant::Todo { type_, .. }
|
||||
| Constant::Invalid { type_, .. } => type_.clone(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn find_node(&self, byte_index: u32) -> Option<Located<'_>> {
|
||||
if !self.location().contains(byte_index) {
|
||||
return None;
|
||||
}
|
||||
Some(match self {
|
||||
Constant::Int { .. }
|
||||
| Constant::Float { .. }
|
||||
| Constant::String { .. }
|
||||
| Constant::Invalid { .. } => Located::Constant(self),
|
||||
|
||||
Constant::Todo { message, .. } => message
|
||||
.iter()
|
||||
.find_map(|message| message.find_node(byte_index))
|
||||
.unwrap_or(Located::Constant(self)),
|
||||
|
||||
Constant::Var {
|
||||
module: Some((module_alias, location)),
|
||||
constructor: Some(constructor),
|
||||
..
|
||||
}
|
||||
| Constant::Record {
|
||||
module: Some((module_alias, location)),
|
||||
record_constructor: Some(constructor),
|
||||
..
|
||||
} if location.contains(byte_index) => match &constructor.variant {
|
||||
ValueConstructorVariant::ModuleConstant { module, .. }
|
||||
| ValueConstructorVariant::ModuleFn { module, .. }
|
||||
| ValueConstructorVariant::Record { module, .. } => Located::ModuleName {
|
||||
location: *location,
|
||||
module_name: module.clone(),
|
||||
module_alias: module_alias.clone(),
|
||||
layer: Layer::Value,
|
||||
},
|
||||
ValueConstructorVariant::LocalVariable { .. } => Located::Constant(self),
|
||||
},
|
||||
Constant::Var { .. } => Located::Constant(self),
|
||||
Constant::Tuple { elements, .. } => elements
|
||||
.iter()
|
||||
.find_map(|element| element.find_node(byte_index))
|
||||
.unwrap_or(Located::Constant(self)),
|
||||
Constant::List { elements, tail, .. } => elements
|
||||
.iter()
|
||||
.find_map(|element| element.find_node(byte_index))
|
||||
.or_else(|| tail.as_deref().and_then(|tail| tail.find_node(byte_index)))
|
||||
.unwrap_or(Located::Constant(self)),
|
||||
Constant::Record {
|
||||
arguments,
|
||||
type_,
|
||||
name,
|
||||
..
|
||||
} => arguments
|
||||
.iter()
|
||||
.flatten()
|
||||
.find_map(|argument| argument.find_node(byte_index, type_, name))
|
||||
.unwrap_or(Located::Constant(self)),
|
||||
Constant::RecordUpdate {
|
||||
record, arguments, ..
|
||||
} => record
|
||||
.base
|
||||
.find_node(byte_index)
|
||||
.or_else(|| {
|
||||
arguments
|
||||
.iter()
|
||||
.find_map(|arg| arg.value.find_node(byte_index))
|
||||
})
|
||||
.unwrap_or(Located::Constant(self)),
|
||||
Constant::BitArray { segments, .. } => segments
|
||||
.iter()
|
||||
.find_map(|segment| segment.find_node(byte_index))
|
||||
.unwrap_or(Located::Constant(self)),
|
||||
Constant::BinaryOperator { left, right, .. } => left
|
||||
.find_node(byte_index)
|
||||
.or_else(|| right.find_node(byte_index))
|
||||
.unwrap_or(Located::Constant(self)),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn definition_location(&self) -> Option<DefinitionLocation> {
|
||||
match self {
|
||||
Constant::Int { .. }
|
||||
| Constant::Float { .. }
|
||||
| Constant::String { .. }
|
||||
| Constant::Tuple { .. }
|
||||
| Constant::List { .. }
|
||||
| Constant::BitArray { .. }
|
||||
| Constant::Todo { .. }
|
||||
| Constant::BinaryOperator { .. }
|
||||
| Constant::Invalid { .. } => None,
|
||||
Constant::Record {
|
||||
record_constructor: value_constructor,
|
||||
..
|
||||
}
|
||||
| Constant::Var {
|
||||
constructor: value_constructor,
|
||||
..
|
||||
} => value_constructor
|
||||
.as_ref()
|
||||
.map(|constructor| constructor.definition_location()),
|
||||
Constant::RecordUpdate { .. } => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn referenced_variables(&self) -> imbl::HashSet<&EcoString> {
|
||||
match self {
|
||||
Constant::Var { name, .. } => imbl::hashset![name],
|
||||
|
||||
Constant::Invalid { .. }
|
||||
| Constant::Int { .. }
|
||||
| Constant::Float { .. }
|
||||
| Constant::String { .. } => imbl::hashset![],
|
||||
|
||||
Constant::Todo { message, .. } => message
|
||||
.as_ref()
|
||||
.map(|message| message.referenced_variables())
|
||||
.unwrap_or(imbl::hashset![]),
|
||||
|
||||
Constant::Tuple { elements, .. } => elements
|
||||
.iter()
|
||||
.map(|element| element.referenced_variables())
|
||||
.fold(imbl::hashset![], imbl::HashSet::union),
|
||||
|
||||
Constant::List { elements, tail, .. } => elements
|
||||
.iter()
|
||||
.map(|element| element.referenced_variables())
|
||||
.chain(tail.iter().map(|tail| tail.referenced_variables()))
|
||||
.fold(imbl::hashset![], imbl::HashSet::union),
|
||||
|
||||
Constant::Record { arguments, .. } => arguments
|
||||
.iter()
|
||||
.flatten()
|
||||
.map(|argument| argument.value.referenced_variables())
|
||||
.fold(imbl::hashset![], imbl::HashSet::union),
|
||||
|
||||
Constant::RecordUpdate {
|
||||
record, arguments, ..
|
||||
} => record.base.referenced_variables().union(
|
||||
arguments
|
||||
.iter()
|
||||
.map(|arg| arg.value.referenced_variables())
|
||||
.fold(imbl::hashset![], imbl::HashSet::union),
|
||||
),
|
||||
|
||||
Constant::BitArray { segments, .. } => segments
|
||||
.iter()
|
||||
.map(|segment| {
|
||||
segment
|
||||
.options
|
||||
.iter()
|
||||
.map(|option| option.referenced_variables())
|
||||
.fold(segment.value.referenced_variables(), imbl::HashSet::union)
|
||||
})
|
||||
.fold(imbl::hashset![], imbl::HashSet::union),
|
||||
|
||||
Constant::BinaryOperator { left, right, .. } => left
|
||||
.referenced_variables()
|
||||
.union(right.referenced_variables()),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn syntactically_eq(&self, other: &Self) -> bool {
|
||||
match (self, other) {
|
||||
(
|
||||
Constant::Todo { message, .. },
|
||||
Constant::Todo {
|
||||
message: other_message,
|
||||
..
|
||||
},
|
||||
) => match (message, other_message) {
|
||||
(None, None) => true,
|
||||
(Some(_), None) | (None, Some(_)) => false,
|
||||
(Some(message), Some(other_message)) => message.syntactically_eq(other_message),
|
||||
},
|
||||
(Constant::Todo { .. }, _) => false,
|
||||
|
||||
(Constant::Int { int_value: n, .. }, Constant::Int { int_value: m, .. }) => n == m,
|
||||
(Constant::Int { .. }, _) => false,
|
||||
|
||||
(Constant::Float { float_value: n, .. }, Constant::Float { float_value: m, .. }) => {
|
||||
n == m
|
||||
}
|
||||
(Constant::Float { .. }, _) => false,
|
||||
|
||||
(
|
||||
Constant::String { value, .. },
|
||||
Constant::String {
|
||||
value: other_value, ..
|
||||
},
|
||||
) => value == other_value,
|
||||
(Constant::String { .. }, _) => false,
|
||||
|
||||
(
|
||||
Constant::Tuple { elements, .. },
|
||||
Constant::Tuple {
|
||||
elements: other_elements,
|
||||
..
|
||||
},
|
||||
) => pairwise_all(elements, other_elements, |(one, other)| {
|
||||
one.syntactically_eq(other)
|
||||
}),
|
||||
(Constant::Tuple { .. }, _) => false,
|
||||
|
||||
(
|
||||
Constant::List { elements, tail, .. },
|
||||
Constant::List {
|
||||
elements: other_elements,
|
||||
tail: other_tail,
|
||||
..
|
||||
},
|
||||
) => {
|
||||
let tails_are_equal = match (tail, other_tail) {
|
||||
(None, None) => true,
|
||||
(None, Some(_)) | (Some(_), None) => false,
|
||||
(Some(tail), Some(other_tail)) => tail.syntactically_eq(other_tail),
|
||||
};
|
||||
tails_are_equal
|
||||
&& pairwise_all(elements, other_elements, |(one, other)| {
|
||||
one.syntactically_eq(other)
|
||||
})
|
||||
}
|
||||
(Constant::List { .. }, _) => false,
|
||||
|
||||
(
|
||||
Constant::Record {
|
||||
module,
|
||||
name,
|
||||
arguments,
|
||||
..
|
||||
},
|
||||
Constant::Record {
|
||||
module: other_module,
|
||||
name: other_name,
|
||||
arguments: other_arguments,
|
||||
..
|
||||
},
|
||||
) => {
|
||||
let modules_are_equal = match (module, other_module) {
|
||||
(None, None) => true,
|
||||
(None, Some(_)) | (Some(_), None) => false,
|
||||
(Some((one, _)), Some((other, _))) => one == other,
|
||||
};
|
||||
|
||||
let arguments_are_equal = match (arguments, other_arguments) {
|
||||
(None, None) => true,
|
||||
(None, Some(_)) | (Some(_), None) => false,
|
||||
(Some(arguments), Some(other_arguments)) => {
|
||||
modules_are_equal
|
||||
&& name == other_name
|
||||
&& pairwise_all(arguments, other_arguments, |(one, other)| {
|
||||
one.label == other.label && one.value.syntactically_eq(&other.value)
|
||||
})
|
||||
}
|
||||
};
|
||||
|
||||
modules_are_equal && arguments_are_equal
|
||||
}
|
||||
(Constant::Record { .. }, _) => false,
|
||||
|
||||
(
|
||||
Constant::RecordUpdate {
|
||||
module,
|
||||
name,
|
||||
record,
|
||||
arguments,
|
||||
..
|
||||
},
|
||||
Constant::RecordUpdate {
|
||||
module: other_module,
|
||||
name: other_name,
|
||||
record: other_record,
|
||||
arguments: other_arguments,
|
||||
..
|
||||
},
|
||||
) => {
|
||||
let modules_are_equal = match (module, other_module) {
|
||||
(None, None) => true,
|
||||
(None, Some(_)) | (Some(_), None) => false,
|
||||
(Some((one, _)), Some((other, _))) => one == other,
|
||||
};
|
||||
|
||||
modules_are_equal
|
||||
&& name == other_name
|
||||
&& record.base.syntactically_eq(&other_record.base)
|
||||
&& pairwise_all(arguments, other_arguments, |(one, other)| {
|
||||
one.label == other.label && one.value.syntactically_eq(&other.value)
|
||||
})
|
||||
}
|
||||
(Constant::RecordUpdate { .. }, _) => false,
|
||||
|
||||
(
|
||||
Constant::BitArray { segments, .. },
|
||||
Constant::BitArray {
|
||||
segments: other_segments,
|
||||
..
|
||||
},
|
||||
) => pairwise_all(segments, other_segments, |(one, other)| {
|
||||
one.syntactically_eq(other)
|
||||
}),
|
||||
(Constant::BitArray { .. }, _) => false,
|
||||
|
||||
(
|
||||
Constant::Var { module, name, .. },
|
||||
Constant::Var {
|
||||
module: other_module,
|
||||
name: other_name,
|
||||
..
|
||||
},
|
||||
) => {
|
||||
let modules_are_equal = match (module, other_module) {
|
||||
(None, None) => true,
|
||||
(None, Some(_)) | (Some(_), None) => false,
|
||||
(Some((one, _)), Some((other, _))) => one == other,
|
||||
};
|
||||
|
||||
modules_are_equal && name == other_name
|
||||
}
|
||||
(Constant::Var { .. }, _) => false,
|
||||
|
||||
(
|
||||
Constant::BinaryOperator {
|
||||
left,
|
||||
right,
|
||||
operator,
|
||||
..
|
||||
},
|
||||
Constant::BinaryOperator {
|
||||
left: other_left,
|
||||
right: other_right,
|
||||
operator: other_operator,
|
||||
..
|
||||
},
|
||||
) => {
|
||||
operator == other_operator
|
||||
&& left.syntactically_eq(other_left)
|
||||
&& right.syntactically_eq(other_right)
|
||||
}
|
||||
(Constant::BinaryOperator { .. }, _) => false,
|
||||
|
||||
(Constant::Invalid { .. }, _) => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// If the constant is a list whose elements are known at compile time, this
|
||||
/// returns a vec of all its elements.
|
||||
/// This can happen with:
|
||||
/// - literal lists: `[1, 2]`
|
||||
/// - literal lists whose tail is also known at compile time:
|
||||
/// - `[1, 2, ..[3, 4]]`
|
||||
/// - `[1, 2, ..a_known_module_constant]`
|
||||
///
|
||||
pub fn list_elements(&self) -> Option<Vec<&Self>> {
|
||||
match self {
|
||||
Constant::List { elements, tail, .. } => {
|
||||
if let Some(tail) = tail {
|
||||
// There's a tail, if it cannot be known at compile time,
|
||||
// then this entire list cannot be known at compile time!
|
||||
let tail_elements = tail.list_elements()?;
|
||||
Some(elements.iter().chain(tail_elements).collect())
|
||||
} else {
|
||||
// There's no tail, we just return the elements
|
||||
Some(elements.iter().collect())
|
||||
}
|
||||
}
|
||||
Constant::Var {
|
||||
constructor: Some(constructor),
|
||||
..
|
||||
} => match &constructor.variant {
|
||||
ValueConstructorVariant::ModuleConstant { literal, .. } => literal.list_elements(),
|
||||
ValueConstructorVariant::LocalVariable { .. }
|
||||
| ValueConstructorVariant::ModuleFn { .. }
|
||||
| ValueConstructorVariant::Record { .. } => None,
|
||||
},
|
||||
|
||||
Constant::Int { .. }
|
||||
| Constant::Float { .. }
|
||||
| Constant::String { .. }
|
||||
| Constant::Tuple { .. }
|
||||
| Constant::Record { .. }
|
||||
| Constant::RecordUpdate { .. }
|
||||
| Constant::BitArray { .. }
|
||||
| Constant::BinaryOperator { .. }
|
||||
| Constant::Var { .. }
|
||||
| Constant::Todo { .. }
|
||||
| Constant::Invalid { .. } => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// If the constant is a record or record update this returns its tag.
|
||||
/// It might return `None` if the record constructor couldn't be inferred.
|
||||
/// For example, if someone wrote a variant that doesn't exist:
|
||||
///
|
||||
/// ```gleam
|
||||
/// pub const wibble = ThisIsNotDefinedAnywhere(1, 2)
|
||||
/// ```
|
||||
///
|
||||
/// In this case the record wouldn't have a constructor, as there's no
|
||||
/// custom type defining it anywhere!
|
||||
///
|
||||
pub(crate) fn constant_record_tag(&self) -> Option<EcoString> {
|
||||
if let Constant::Record {
|
||||
record_constructor: Some(constructor),
|
||||
..
|
||||
} = self
|
||||
&& let ValueConstructorVariant::Record { name, .. } = &constructor.variant
|
||||
{
|
||||
Some(name.clone())
|
||||
} else if let Constant::RecordUpdate { name, .. } = self {
|
||||
Some(name.clone())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl HasType for TypedConstant {
|
||||
fn type_(&self) -> Arc<Type> {
|
||||
self.type_()
|
||||
}
|
||||
}
|
||||
|
||||
impl<A> Constant<A> {
|
||||
pub fn location(&self) -> SrcSpan {
|
||||
match self {
|
||||
Constant::Int { location, .. }
|
||||
| Constant::List { location, .. }
|
||||
| Constant::Float { location, .. }
|
||||
| Constant::Tuple { location, .. }
|
||||
| Constant::String { location, .. }
|
||||
| Constant::Record { location, .. }
|
||||
| Constant::RecordUpdate { location, .. }
|
||||
| Constant::BitArray { location, .. }
|
||||
| Constant::Var { location, .. }
|
||||
| Constant::Invalid { location, .. }
|
||||
| Constant::Todo { location, .. }
|
||||
| Constant::BinaryOperator { location, .. } => *location,
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn can_have_multiple_per_line(&self) -> bool {
|
||||
match self {
|
||||
Constant::Int { .. }
|
||||
| Constant::Float { .. }
|
||||
| Constant::String { .. }
|
||||
| Constant::Var { .. } => true,
|
||||
|
||||
Constant::Tuple { .. }
|
||||
| Constant::Todo { .. }
|
||||
| Constant::List { .. }
|
||||
| Constant::Record { .. }
|
||||
| Constant::RecordUpdate { .. }
|
||||
| Constant::BitArray { .. }
|
||||
| Constant::BinaryOperator { .. }
|
||||
| Constant::Invalid { .. } => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<A> HasLocation for Constant<A> {
|
||||
fn location(&self) -> SrcSpan {
|
||||
self.location()
|
||||
}
|
||||
}
|
||||
|
||||
impl<A> bit_array::GetLiteralValue for Constant<A> {
|
||||
fn as_int_literal(&self) -> Option<BigInt> {
|
||||
if let Constant::Int { int_value, .. } = self {
|
||||
Some(int_value.clone())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,437 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// SPDX-FileCopyrightText: 2026 The Gleam contributors
|
||||
|
||||
use crate::{
|
||||
ast::{BinOp, ClauseGuard, TypedClauseGuard, TypedExpr, UntypedClauseGuard},
|
||||
reference::ReferenceKind,
|
||||
type_::{
|
||||
Error, ExprTyper, FieldAccessUsage, ModuleValueConstructor, RecordAccessor, Type,
|
||||
ValueConstructorVariant, ValueUsage, bool,
|
||||
error::{FeatureKind, convert_unify_error},
|
||||
float, int, string, unify,
|
||||
},
|
||||
};
|
||||
use ecow::EcoString;
|
||||
use src_span::SrcSpan;
|
||||
|
||||
pub struct GuardTyper<'expression_typer, 'env, 'module> {
|
||||
typer: &'expression_typer mut ExprTyper<'env, 'module>,
|
||||
}
|
||||
|
||||
impl<'expression_typer, 'env, 'module> GuardTyper<'expression_typer, 'env, 'module> {
|
||||
pub fn new(typer: &'expression_typer mut ExprTyper<'env, 'module>) -> Self {
|
||||
Self { typer }
|
||||
}
|
||||
|
||||
pub fn infer(mut self, guard: UntypedClauseGuard) -> TypedClauseGuard {
|
||||
self.do_infer(guard)
|
||||
}
|
||||
|
||||
fn do_infer(&mut self, guard: UntypedClauseGuard) -> TypedClauseGuard {
|
||||
match guard {
|
||||
ClauseGuard::Invalid { .. } => {
|
||||
unreachable!("untyped guard should never be invalid")
|
||||
}
|
||||
|
||||
ClauseGuard::Var { location, name, .. } => {
|
||||
match self.infer_clause_guard_variable(name, location) {
|
||||
Ok(variable) => variable,
|
||||
Err(error) => {
|
||||
self.typer.problems.error(error);
|
||||
ClauseGuard::Invalid {
|
||||
location,
|
||||
type_: self.typer.new_unbound_var(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ClauseGuard::TupleIndex {
|
||||
location,
|
||||
tuple,
|
||||
index,
|
||||
..
|
||||
} => {
|
||||
let tuple = self.do_infer(*tuple);
|
||||
let index_type = match tuple.type_().as_ref() {
|
||||
Type::Tuple { elements } => match elements.get(index as usize) {
|
||||
Some(type_) => type_.clone(),
|
||||
// If the index is outside the tuple range, then we
|
||||
// report the error and return an unbound type to keep
|
||||
// going.
|
||||
None => {
|
||||
self.typer.problems.error(Error::OutOfBoundsTupleIndex {
|
||||
location,
|
||||
index,
|
||||
size: elements.len(),
|
||||
});
|
||||
self.typer.new_unbound_var()
|
||||
}
|
||||
},
|
||||
|
||||
tuple_type if tuple_type.is_unbound() => {
|
||||
self.typer.problems.error(Error::NotATupleUnbound {
|
||||
location: tuple.location(),
|
||||
});
|
||||
self.typer.new_unbound_var()
|
||||
}
|
||||
|
||||
Type::Named { .. } | Type::Fn { .. } | Type::Var { .. } => {
|
||||
self.typer.problems.error(Error::NotATuple {
|
||||
location: tuple.location(),
|
||||
given: tuple.type_(),
|
||||
});
|
||||
self.typer.new_unbound_var()
|
||||
}
|
||||
};
|
||||
|
||||
ClauseGuard::TupleIndex {
|
||||
location,
|
||||
index,
|
||||
type_: index_type,
|
||||
tuple: Box::new(tuple),
|
||||
}
|
||||
}
|
||||
|
||||
ClauseGuard::FieldAccess {
|
||||
label_location,
|
||||
label,
|
||||
container,
|
||||
index: _,
|
||||
type_: (),
|
||||
} => {
|
||||
let container_location = container.location();
|
||||
let result = if let ClauseGuard::Var { name, location, .. } = *container {
|
||||
// If the container looks like a regular variable, then this
|
||||
// could either be a module select, or a record access.
|
||||
match self.infer_clause_guard_variable(name.clone(), location) {
|
||||
// If the variable itself cannot be inferred as one, then
|
||||
// it could really be a module select. We try that one
|
||||
// as an alternative.
|
||||
Err(error) => self.infer_guard_module_access(
|
||||
name,
|
||||
label,
|
||||
location,
|
||||
label_location,
|
||||
error,
|
||||
),
|
||||
// Otherwise that's a proper variable and not a module name,
|
||||
// so the whole expression has to be inferred as a regular
|
||||
// record access.
|
||||
Ok(variable) => {
|
||||
self.infer_guard_record_access(variable, label, label_location)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// If it doesn't this has to be a regular record access and
|
||||
// we try and infer it as such.
|
||||
let inferred_container = self.do_infer(*container.clone());
|
||||
self.infer_guard_record_access(inferred_container, label, label_location)
|
||||
};
|
||||
|
||||
match result {
|
||||
Ok(inferred) => inferred,
|
||||
Err(error) => {
|
||||
self.typer.problems.error(error);
|
||||
ClauseGuard::Invalid {
|
||||
location: container_location.merge(&label_location),
|
||||
type_: self.typer.new_unbound_var(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ClauseGuard::ModuleSelect { .. } => {
|
||||
unreachable!("untyped guard should never be module select")
|
||||
}
|
||||
|
||||
ClauseGuard::Not {
|
||||
location,
|
||||
expression,
|
||||
} => {
|
||||
let expression = self.do_infer(*expression);
|
||||
if let Err(error) = unify(bool(), expression.type_()) {
|
||||
self.typer
|
||||
.problems
|
||||
.error(convert_unify_error(error, expression.location()));
|
||||
}
|
||||
ClauseGuard::Not {
|
||||
location,
|
||||
expression: Box::new(expression),
|
||||
}
|
||||
}
|
||||
|
||||
ClauseGuard::Constant(constant) => {
|
||||
ClauseGuard::Constant(self.typer.infer_const(&None, constant))
|
||||
}
|
||||
|
||||
ClauseGuard::Block { value, location } => ClauseGuard::Block {
|
||||
location,
|
||||
value: Box::new(self.do_infer(*value)),
|
||||
},
|
||||
|
||||
ClauseGuard::BinaryOperator {
|
||||
location,
|
||||
operator,
|
||||
operator_start,
|
||||
left,
|
||||
right,
|
||||
} => {
|
||||
let left = self.do_infer(*left);
|
||||
let right = self.do_infer(*right);
|
||||
|
||||
match operator {
|
||||
BinOp::And | BinOp::Or => {
|
||||
if let Err(error) = unify(bool(), left.type_()) {
|
||||
self.typer
|
||||
.problems
|
||||
.error(convert_unify_error(error, left.location()));
|
||||
}
|
||||
if let Err(error) = unify(bool(), right.type_()) {
|
||||
self.typer
|
||||
.problems
|
||||
.error(convert_unify_error(error, right.location()));
|
||||
}
|
||||
}
|
||||
|
||||
BinOp::Eq | BinOp::NotEq => {
|
||||
if let Err(error) = unify(left.type_(), right.type_()) {
|
||||
self.typer
|
||||
.problems
|
||||
.error(convert_unify_error(error, right.location()));
|
||||
}
|
||||
}
|
||||
|
||||
BinOp::GtInt
|
||||
| BinOp::GtEqInt
|
||||
| BinOp::LtInt
|
||||
| BinOp::LtEqInt
|
||||
| BinOp::AddInt
|
||||
| BinOp::SubInt
|
||||
| BinOp::DivInt
|
||||
| BinOp::MultInt
|
||||
| BinOp::RemainderInt => {
|
||||
self.typer
|
||||
.track_feature_usage(FeatureKind::ArithmeticInGuards, location);
|
||||
// If both operands are floats, then we use a more specialised
|
||||
// error.
|
||||
if left.type_().is_float() && right.type_().is_float() {
|
||||
self.typer.problems.error(Error::IntOperatorOnFloats {
|
||||
operator,
|
||||
location: SrcSpan::new(
|
||||
operator_start,
|
||||
operator_start + operator.size(),
|
||||
),
|
||||
});
|
||||
} else {
|
||||
if let Err(error) = unify(int(), left.type_()) {
|
||||
self.typer
|
||||
.problems
|
||||
.error(convert_unify_error(error, left.location()));
|
||||
}
|
||||
if let Err(error) = unify(int(), right.type_()) {
|
||||
self.typer
|
||||
.problems
|
||||
.error(convert_unify_error(error, right.location()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BinOp::GtFloat
|
||||
| BinOp::GtEqFloat
|
||||
| BinOp::LtFloat
|
||||
| BinOp::LtEqFloat
|
||||
| BinOp::AddFloat
|
||||
| BinOp::SubFloat
|
||||
| BinOp::DivFloat
|
||||
| BinOp::MultFloat => {
|
||||
self.typer
|
||||
.track_feature_usage(FeatureKind::ArithmeticInGuards, location);
|
||||
|
||||
// If both operands are int then we use a more specialised
|
||||
// error
|
||||
if left.type_().is_int() && right.type_().is_int() {
|
||||
self.typer.problems.error(Error::FloatOperatorOnInts {
|
||||
operator,
|
||||
location: SrcSpan::new(
|
||||
operator_start,
|
||||
operator_start + operator.size(),
|
||||
),
|
||||
});
|
||||
} else {
|
||||
if let Err(error) = unify(float(), left.type_()) {
|
||||
self.typer
|
||||
.problems
|
||||
.error(convert_unify_error(error, left.location()));
|
||||
}
|
||||
if let Err(error) = unify(float(), right.type_()) {
|
||||
self.typer
|
||||
.problems
|
||||
.error(convert_unify_error(error, right.location()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BinOp::Concatenate => {
|
||||
self.typer
|
||||
.track_feature_usage(FeatureKind::ConcatenateInGuards, location);
|
||||
|
||||
if let Err(error) = unify(string(), left.type_()) {
|
||||
self.typer
|
||||
.problems
|
||||
.error(convert_unify_error(error, left.location()));
|
||||
}
|
||||
if let Err(error) = unify(string(), right.type_()) {
|
||||
self.typer
|
||||
.problems
|
||||
.error(convert_unify_error(error, right.location()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ClauseGuard::BinaryOperator {
|
||||
location,
|
||||
operator,
|
||||
operator_start,
|
||||
left: Box::new(left),
|
||||
right: Box::new(right),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn infer_clause_guard_variable(
|
||||
&mut self,
|
||||
name: EcoString,
|
||||
location: SrcSpan,
|
||||
) -> Result<TypedClauseGuard, Error> {
|
||||
let constructor =
|
||||
self.typer
|
||||
.infer_value_constructor(&None, &name, &location, ValueUsage::Other)?;
|
||||
|
||||
// We cannot support all values in guard expressions as the BEAM does not
|
||||
let (definition_location, origin) = match &constructor.variant {
|
||||
ValueConstructorVariant::LocalVariable { location, origin } => {
|
||||
(*location, origin.clone())
|
||||
}
|
||||
|
||||
ValueConstructorVariant::ModuleFn { .. } | ValueConstructorVariant::Record { .. } => {
|
||||
return Err(Error::NonLocalClauseGuardVariable { location, name });
|
||||
}
|
||||
|
||||
ValueConstructorVariant::ModuleConstant { literal, .. } => {
|
||||
return Ok(ClauseGuard::Constant(literal.clone()));
|
||||
}
|
||||
};
|
||||
|
||||
Ok(ClauseGuard::Var {
|
||||
location,
|
||||
name,
|
||||
origin,
|
||||
type_: constructor.type_,
|
||||
definition_location,
|
||||
})
|
||||
}
|
||||
|
||||
fn infer_guard_record_access(
|
||||
&mut self,
|
||||
container: TypedClauseGuard,
|
||||
label: EcoString,
|
||||
location: SrcSpan,
|
||||
) -> Result<TypedClauseGuard, Error> {
|
||||
let container = Box::new(container);
|
||||
let container_type = container.type_();
|
||||
let RecordAccessor {
|
||||
index,
|
||||
label,
|
||||
type_,
|
||||
documentation: _,
|
||||
} = self.typer.infer_known_record_access(
|
||||
container_type,
|
||||
container.location(),
|
||||
FieldAccessUsage::Other,
|
||||
location,
|
||||
label,
|
||||
)?;
|
||||
Ok(ClauseGuard::FieldAccess {
|
||||
container,
|
||||
label,
|
||||
index: Some(index),
|
||||
label_location: location,
|
||||
type_,
|
||||
})
|
||||
}
|
||||
|
||||
fn infer_guard_module_access(
|
||||
&mut self,
|
||||
name: EcoString,
|
||||
label: EcoString,
|
||||
module_location: SrcSpan,
|
||||
label_location: SrcSpan,
|
||||
record_access_error: Error,
|
||||
) -> Result<TypedClauseGuard, Error> {
|
||||
let module_access = self
|
||||
.typer
|
||||
.infer_module_access(&name, label, &module_location, label_location)
|
||||
.and_then(|module_select| {
|
||||
if let TypedExpr::ModuleSelect {
|
||||
location,
|
||||
field_start: _,
|
||||
type_,
|
||||
label,
|
||||
module_name,
|
||||
module_alias,
|
||||
constructor,
|
||||
} = module_select
|
||||
{
|
||||
match constructor {
|
||||
ModuleValueConstructor::Constant {
|
||||
literal,
|
||||
location: definition_location,
|
||||
..
|
||||
} => {
|
||||
self.typer.environment.references.register_value_reference(
|
||||
module_name.clone(),
|
||||
label.clone(),
|
||||
&label,
|
||||
label_location,
|
||||
ReferenceKind::Qualified {
|
||||
module_alias: module_alias.clone(),
|
||||
module_location,
|
||||
},
|
||||
);
|
||||
|
||||
Ok(ClauseGuard::ModuleSelect {
|
||||
location,
|
||||
field_start: label_location.start,
|
||||
definition_location,
|
||||
type_,
|
||||
label,
|
||||
module_name,
|
||||
module_alias,
|
||||
literal,
|
||||
})
|
||||
}
|
||||
|
||||
ModuleValueConstructor::Record { .. }
|
||||
| ModuleValueConstructor::Fn { .. } => {
|
||||
Err(Error::RecordAccessUnknownType { location })
|
||||
}
|
||||
}
|
||||
} else {
|
||||
Err(Error::RecordAccessUnknownType {
|
||||
location: module_location,
|
||||
})
|
||||
}
|
||||
});
|
||||
|
||||
// If the name is in the environment, use the original error from
|
||||
// inferring the record access, so that we can suggest possible
|
||||
// misspellings of field names
|
||||
if self.typer.environment.scope.contains_key(&name) {
|
||||
module_access.map_err(|_| record_access_error)
|
||||
} else {
|
||||
module_access
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
// SPDX-FileCopyrightText: 2023 The Gleam contributors
|
||||
|
||||
use crate::{assert_module_error, assert_module_infer};
|
||||
|
||||
#[test]
|
||||
fn nested_record_access() {
|
||||
assert_module_infer!(
|
||||
r#"
|
||||
pub type A {
|
||||
A(b: B)
|
||||
}
|
||||
|
||||
pub type B {
|
||||
B(c: C)
|
||||
}
|
||||
|
||||
pub type C {
|
||||
C(d: Bool)
|
||||
}
|
||||
|
||||
pub fn a(a: A) {
|
||||
case a {
|
||||
_ if a.b.c.d -> 1
|
||||
_ -> 0
|
||||
}
|
||||
}
|
||||
"#,
|
||||
vec![
|
||||
("A", "fn(B) -> A"),
|
||||
("B", "fn(C) -> B"),
|
||||
("C", "fn(Bool) -> C"),
|
||||
("a", "fn(A) -> Int"),
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn string_variable_access() {
|
||||
assert_module_error!(
|
||||
r#"
|
||||
pub fn a(a: String) {
|
||||
case a {
|
||||
_ if a.b -> 1
|
||||
_ -> 0
|
||||
}
|
||||
}
|
||||
"#
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn qualified_record() {
|
||||
assert_module_infer!(
|
||||
("wibble", "pub type Wibble { Wibble Wobble }"),
|
||||
"
|
||||
import wibble
|
||||
|
||||
pub fn main(wibble: wibble.Wibble) {
|
||||
case wibble {
|
||||
w if w == wibble.Wobble -> True
|
||||
_ -> False
|
||||
}
|
||||
}
|
||||
",
|
||||
vec![("main", "fn(Wibble) -> Bool")]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn qualified_record_with_arguments() {
|
||||
assert_module_infer!(
|
||||
(
|
||||
"wibble",
|
||||
"pub type Wibble { Wibble(Int) Wobble(Int, Float) }"
|
||||
),
|
||||
"
|
||||
import wibble
|
||||
|
||||
pub fn main(wibble: wibble.Wibble) {
|
||||
case wibble {
|
||||
w if w == wibble.Wobble(1, 3.8) -> True
|
||||
_ -> False
|
||||
}
|
||||
}
|
||||
",
|
||||
vec![("main", "fn(Wibble) -> Bool")]
|
||||
);
|
||||
}
|
||||
Reference in new issue
Block a user