waalge
/
aiken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix latest clippy warnings.

This commit is contained in:
KtorZ 2024-10-25 11:27:28 +02:00
parent e97fe332b1
commit 93d0191489
No known key found for this signature in database
GPG Key ID: 33173CB6F77F4277
14 changed files with 117 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
crates/aiken-lang/src/tipo/environment.rs
View File

@ -91,6 +91,7 @@ pub struct Environment<'a> {
}
impl<'a> Environment<'a> {
#[allow(clippy::result_large_err)]
pub fn find_module(&self, fragments: &[String], location: Span) -> Result<&'a TypeInfo, Error> {
let mut name = fragments.join("/");
@ -158,6 +159,7 @@ impl<'a> Environment<'a> {
}
}
#[allow(clippy::result_large_err)]
pub fn match_fun_type(
&mut self,
tipo: Rc<Type>,
@ -216,6 +218,7 @@ impl<'a> Environment<'a> {
})
}
#[allow(clippy::result_large_err)]
fn custom_type_accessors<A>(
&mut self,
constructors: &[RecordConstructor<A>],
@ -368,6 +371,7 @@ impl<'a> Environment<'a> {
}
}
#[allow(clippy::result_large_err)]
pub fn get_type_constructor_mut(
&mut self,
name: &str,
@ -388,6 +392,7 @@ impl<'a> Environment<'a> {
}
/// Lookup a type in the current scope.
#[allow(clippy::result_large_err)]
pub fn get_type_constructor(
&mut self,
module_alias: &Option<String>,
@ -434,7 +439,7 @@ impl<'a> Environment<'a> {
}
/// Lookup a value constructor in the current scope.
///
#[allow(clippy::result_large_err)]
pub fn get_value_constructor(
&mut self,
module: Option<&String>,
@ -585,6 +590,7 @@ impl<'a> Environment<'a> {
/// Map a type in the current scope. Errors if the module
/// already has a type with that name, unless the type is
/// from the prelude.
#[allow(clippy::result_large_err)]
pub fn insert_type_constructor(
&mut self,
type_name: String,
@ -737,6 +743,7 @@ impl<'a> Environment<'a> {
.collect()
}
#[allow(clippy::result_large_err)]
fn make_type_vars(
&mut self,
args: &[String],
@ -827,6 +834,7 @@ impl<'a> Environment<'a> {
self.previous_id
}
#[allow(clippy::result_large_err)]
pub fn register_import(&mut self, def: &UntypedDefinition) -> Result<(), Error> {
match def {
Definition::Use(Use {
@ -985,6 +993,7 @@ impl<'a> Environment<'a> {
}
/// Iterate over a module, registering any new types created by the module into the typer
#[allow(clippy::result_large_err)]
pub fn register_types(
&mut self,
definitions: Vec<&'a UntypedDefinition>,
@ -1065,6 +1074,7 @@ impl<'a> Environment<'a> {
}
}
#[allow(clippy::result_large_err)]
pub fn register_type(
&mut self,
def: &'a UntypedDefinition,
@ -1182,6 +1192,7 @@ impl<'a> Environment<'a> {
}
#[allow(clippy::too_many_arguments)]
#[allow(clippy::result_large_err)]
fn register_function(
&mut self,
name: &str,
@ -1241,6 +1252,7 @@ impl<'a> Environment<'a> {
Ok(())
}
#[allow(clippy::result_large_err)]
pub fn register_values(
&mut self,
def: &'a UntypedDefinition,
@ -1512,6 +1524,7 @@ impl<'a> Environment<'a> {
///
/// It two types are found to not be the same an error is returned.
#[allow(clippy::only_used_in_recursion)]
#[allow(clippy::result_large_err)]
pub fn unify(
&mut self,
lhs: Rc<Type>,
@ -1719,6 +1732,7 @@ impl<'a> Environment<'a> {
/// Checks that the given patterns are exhaustive for given type.
/// https://github.com/elm/compiler/blob/047d5026fe6547c842db65f7196fed3f0b4743ee/compiler/src/Nitpick/PatternMatches.hs#L397-L475
/// http://moscova.inria.fr/~maranget/papers/warn/index.html
#[allow(clippy::result_large_err)]
pub fn check_exhaustiveness(
&mut self,
unchecked_patterns: &[&TypedPattern],
@ -1768,7 +1782,7 @@ impl<'a> Environment<'a> {
}
/// Lookup constructors for type in the current scope.
///
#[allow(clippy::result_large_err)]
pub fn get_constructors_for_type(
&mut self,
full_module_name: &String,
@ -1868,6 +1882,7 @@ pub enum EntityKind {
/// prevents the algorithm from inferring recursive types, which
/// could cause naively-implemented type checking to diverge.
/// While traversing the type tree.
#[allow(clippy::result_large_err)]
fn unify_unbound_type(tipo: Rc<Type>, own_id: u64, location: Span) -> Result<(), Error> {
if let Type::Var { tipo, alias } = tipo.deref() {
let new_value = match tipo.borrow().deref() {
@ -1942,6 +1957,7 @@ fn unify_unbound_type(tipo: Rc<Type>, own_id: u64, location: Span) -> Result<(),
}
}
#[allow(clippy::result_large_err)]
fn unify_enclosed_type(e1: Rc<Type>, e2: Rc<Type>, result: Result<(), Error>) -> Result<(), Error> {
// If types cannot unify, show the type error with the enclosing types, e1 and e2.
match result {
@ -1962,6 +1978,7 @@ fn unify_enclosed_type(e1: Rc<Type>, e2: Rc<Type>, result: Result<(), Error>) ->
}
}
#[allow(clippy::result_large_err)]
fn assert_unique_type_name<'a>(
names: &mut HashMap<&'a str, &'a Span>,
name: &'a str,
@ -1977,6 +1994,7 @@ fn assert_unique_type_name<'a>(
}
}
#[allow(clippy::result_large_err)]
fn assert_unique_value_name<'a>(
names: &mut HashMap<String, &'a Span>,
name: &str,
@ -1992,6 +2010,7 @@ fn assert_unique_value_name<'a>(
}
}
#[allow(clippy::result_large_err)]
fn assert_unique_const_name<'a>(
names: &mut HashMap<String, &'a Span>,
name: &str,

1
crates/aiken-lang/src/tipo/exhaustive.rs
View File

@ -530,6 +530,7 @@ fn list_constructors() -> Vec<tipo::ValueConstructor> {
]
}
#[allow(clippy::result_large_err)]
pub(super) fn simplify(
environment: &mut Environment,
value: &ast::TypedPattern,

47
crates/aiken-lang/src/tipo/expr.rs
View File

@ -32,6 +32,7 @@ use std::{
};
use vec1::Vec1;
#[allow(clippy::result_large_err)]
pub(crate) fn infer_function(
fun: &UntypedFunction,
module_name: &str,
@ -246,6 +247,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
}
}
#[allow(clippy::result_large_err)]
fn check_when_exhaustiveness(
&mut self,
typed_clauses: &[TypedClause],
@ -265,6 +267,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
Ok(())
}
#[allow(clippy::result_large_err)]
pub fn do_infer_call(
&mut self,
fun: UntypedExpr,
@ -278,6 +281,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
Ok((fun, args, typ))
}
#[allow(clippy::result_large_err)]
pub fn do_infer_call_with_known_fun<F>(
&mut self,
fun: TypedExpr,
@ -334,6 +338,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
Ok((fun, arguments, return_type))
}
#[allow(clippy::result_large_err)]
pub fn do_infer_fn(
&mut self,
args: Vec<UntypedArg>,
@ -386,6 +391,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
self.infer_fn_with_known_types(arguments, body, return_type)
}
#[allow(clippy::result_large_err)]
fn get_field_map(
&mut self,
constructor: &TypedExpr,
@ -426,6 +432,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
/// Crawl the AST, annotating each node with the inferred type or
/// returning an error.
#[allow(clippy::result_large_err)]
pub fn infer(&mut self, expr: UntypedExpr) -> Result<TypedExpr, Error> {
match expr {
UntypedExpr::ErrorTerm { location } => Ok(self.infer_error_term(location)),
@ -573,6 +580,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
}
}
#[allow(clippy::result_large_err)]
fn infer_bytearray(
&mut self,
bytes: Vec<u8>,
@ -597,6 +605,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn infer_curve_point(
&mut self,
curve: Curve,
@ -618,6 +627,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn infer_trace_if_false(
&mut self,
value: UntypedExpr,
@ -701,6 +711,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
}
}
#[allow(clippy::result_large_err)]
fn infer_binop(
&mut self,
name: BinOp,
@ -771,6 +782,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn infer_record_update(
&mut self,
constructor: UntypedExpr,
@ -897,6 +909,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn infer_un_op(
&mut self,
location: Span,
@ -1035,6 +1048,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
None
}
#[allow(clippy::result_large_err)]
fn infer_field_access(
&mut self,
container: UntypedExpr,
@ -1077,6 +1091,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
}
}
#[allow(clippy::result_large_err)]
fn infer_module_access(
&mut self,
module_alias: &str,
@ -1145,6 +1160,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn infer_record_access(
&mut self,
record: UntypedExpr,
@ -1157,6 +1173,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
self.infer_known_record_access(record, label, location)
}
#[allow(clippy::result_large_err)]
fn infer_known_record_access(
&mut self,
record: TypedExpr,
@ -1244,6 +1261,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn infer_param(
&mut self,
untyped_arg: UntypedArg,
@ -1288,6 +1306,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
Ok((typed_arg, extra_assignment))
}
#[allow(clippy::result_large_err)]
pub fn infer_assignment(
&mut self,
untyped_pattern: UntypedPattern,
@ -1482,6 +1501,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn infer_call(
&mut self,
fun: UntypedExpr,
@ -1500,6 +1520,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn infer_call_argument(
&mut self,
value: UntypedExpr,
@ -1548,6 +1569,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
Ok(value)
}
#[allow(clippy::result_large_err)]
fn infer_clause(
&mut self,
clause: UntypedClause,
@ -1583,6 +1605,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
.collect())
}
#[allow(clippy::result_large_err)]
fn infer_clause_pattern(
&mut self,
patterns: Vec1<UntypedPattern>,
@ -1604,6 +1627,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
Ok(typed_patterns)
}
#[allow(clippy::result_large_err)]
fn infer_if(
&mut self,
branches: Vec1<UntypedIfBranch>,
@ -1655,6 +1679,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn infer_if_branch(&mut self, branch: UntypedIfBranch) -> Result<TypedIfBranch, Error> {
let (condition, body, is) = match branch.is {
Some(is) => self.in_new_scope(|typer| {
@ -1728,6 +1753,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
pub fn infer_fn(
&mut self,
args: Vec<UntypedArg>,
@ -1754,6 +1780,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
pub fn infer_fn_with_known_types(
&mut self,
args: Vec<TypedArg>,
@ -1842,6 +1869,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
}
}
#[allow(clippy::result_large_err)]
fn infer_list(
&mut self,
elements: Vec<UntypedExpr>,
@ -1887,6 +1915,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn infer_logical_op_chain(
&mut self,
kind: LogicalOpChainKind,
@ -1934,6 +1963,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
Ok(chain)
}
#[allow(clippy::result_large_err)]
fn infer_pipeline(&mut self, expressions: Vec1<UntypedExpr>) -> Result<TypedExpr, Error> {
PipeTyper::infer(self, expressions)
}
@ -2132,6 +2162,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
}
}
#[allow(clippy::result_large_err)]
fn infer_seq(&mut self, location: Span, untyped: Vec<UntypedExpr>) -> Result<TypedExpr, Error> {
// Search for backpassing.
let mut breakpoint = None;
@ -2252,6 +2283,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
}
}
#[allow(clippy::result_large_err)]
fn infer_pair(
&mut self,
fst: UntypedExpr,
@ -2272,6 +2304,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn infer_tuple(&mut self, elems: Vec<UntypedExpr>, location: Span) -> Result<TypedExpr, Error> {
let mut typed_elems = vec![];
@ -2293,6 +2326,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn infer_tuple_index(
&mut self,
tuple_or_pair: UntypedExpr,
@ -2350,6 +2384,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
TypedExpr::ErrorTerm { location, tipo }
}
#[allow(clippy::result_large_err)]
fn infer_trace_arg(&mut self, arg: UntypedExpr) -> Result<TypedExpr, Error> {
let typed_arg = self.infer(arg)?;
match self.unify(
@ -2366,6 +2401,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
}
}
#[allow(clippy::result_large_err)]
fn infer_trace(
&mut self,
kind: TraceKind,
@ -2431,6 +2467,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
}
}
#[allow(clippy::result_large_err)]
pub fn infer_value_constructor(
&mut self,
module: &Option<String>,
@ -2534,6 +2571,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn infer_var(&mut self, name: String, location: Span) -> Result<TypedExpr, Error> {
let constructor = self.infer_value_constructor(&None, &name, &location)?;
@ -2544,6 +2582,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn infer_when(
&mut self,
subject: UntypedExpr,
@ -2604,6 +2643,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
})
}
#[allow(clippy::result_large_err)]
fn instantiate(
&mut self,
t: Rc<Type>,
@ -2615,15 +2655,18 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
Ok(result)
}
#[allow(clippy::result_large_err)]
pub fn new_unbound_var(&mut self) -> Rc<Type> {
self.environment.new_unbound_var()
}
#[allow(clippy::result_large_err)]
pub fn type_from_annotation(&mut self, annotation: &Annotation) -> Result<Rc<Type>, Error> {
self.hydrator
.type_from_annotation(annotation, self.environment)
}
#[allow(clippy::result_large_err)]
fn unify(
&mut self,
t1: Rc<Type>,
@ -2635,6 +2678,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
}
}
#[allow(clippy::result_large_err)]
fn recover_from_no_assignment(
result: Result<(), Error>,
span: Span,
@ -2653,6 +2697,7 @@ fn recover_from_no_assignment(
result.map(|()| None)
}
#[allow(clippy::result_large_err)]
fn assert_no_assignment(expr: &UntypedExpr) -> Result<(), Error> {
match expr {
UntypedExpr::Assignment {
@ -2692,6 +2737,7 @@ fn assert_no_assignment(expr: &UntypedExpr) -> Result<(), Error> {
}
}
#[allow(clippy::result_large_err)]
fn assert_assignment(expr: TypedExpr) -> Result<TypedExpr, Error> {
if !matches!(expr, TypedExpr::Assignment { .. }) {
if expr.tipo().is_void() {
@ -2724,6 +2770,7 @@ fn assert_assignment(expr: TypedExpr) -> Result<TypedExpr, Error> {
Ok(expr)
}
#[allow(clippy::result_large_err)]
pub fn ensure_serialisable(is_top_level: bool, t: Rc<Type>, location: Span) -> Result<(), Error> {
match t.deref() {
Type::App {

8
crates/aiken-lang/src/tipo/fields.rs
View File

@ -1,9 +1,7 @@
use std::collections::{HashMap, HashSet};
use itertools::Itertools;
use super::error::{Error, UnknownLabels};
use crate::ast::{CallArg, Span};
use itertools::Itertools;
use std::collections::{HashMap, HashSet};
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct FieldMap {
@ -21,6 +19,7 @@ impl FieldMap {
}
}
#[allow(clippy::result_large_err)]
pub fn insert(&mut self, label: String, index: usize, location: &Span) -> Result<(), Error> {
match self.fields.insert(label.clone(), (index, *location)) {
Some((_, location_other)) => {
@ -52,6 +51,7 @@ impl FieldMap {
/// Reorder an argument list so that labelled fields supplied out-of-order are
/// in the correct order.
#[allow(clippy::result_large_err)]
pub fn reorder<A>(&self, args: &mut [CallArg<A>], location: Span) -> Result<(), Error> {
let mut last_labeled_arguments_given: Option<&CallArg<A>> = None;
let mut seen_labels = std::collections::HashSet::new();

4
crates/aiken-lang/src/tipo/hydrator.rs
View File

@ -80,6 +80,7 @@ impl Hydrator {
self.rigid_type_names.clone()
}
#[allow(clippy::result_large_err)]
pub fn type_from_option_annotation(
&mut self,
ast: &Option<Annotation>,
@ -91,6 +92,7 @@ impl Hydrator {
}
}
#[allow(clippy::result_large_err)]
pub fn type_from_annotation(
&mut self,
annotation: &Annotation,
@ -110,7 +112,7 @@ impl Hydrator {
}
/// Construct a Type from an AST Type annotation.
///
#[allow(clippy::result_large_err)]
fn do_type_from_annotation<'a>(
&mut self,
annotation: &'a Annotation,

4
crates/aiken-lang/src/tipo/infer.rs
View File

@ -20,6 +20,7 @@ use std::{borrow::Borrow, collections::HashMap, ops::Deref, rc::Rc};
impl UntypedModule {
#[allow(clippy::too_many_arguments)]
#[allow(clippy::result_large_err)]
pub fn infer(
mut self,
id_gen: &IdGenerator,
@ -158,6 +159,7 @@ impl UntypedModule {
}
}
#[allow(clippy::result_large_err)]
fn infer_definition(
def: UntypedDefinition,
module_name: &String,
@ -687,6 +689,7 @@ fn infer_definition(
}
}
#[allow(clippy::result_large_err)]
fn infer_fuzzer(
environment: &mut Environment<'_>,
expected_inner_type: Option<Rc<Type>>,
@ -763,6 +766,7 @@ fn infer_fuzzer(
}
}
#[allow(clippy::result_large_err)]
fn annotate_fuzzer(tipo: &Type, location: &Span) -> Result<Annotation, Error> {
match tipo {
Type::App {

4
crates/aiken-lang/src/tipo/pattern.rs
View File

@ -36,6 +36,7 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
}
}
#[allow(clippy::result_large_err)]
fn insert_variable(
&mut self,
name: &str,
@ -91,6 +92,7 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
}
}
#[allow(clippy::result_large_err)]
pub fn infer_alternative_pattern(
&mut self,
pattern: UntypedPattern,
@ -122,6 +124,7 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
}
}
#[allow(clippy::result_large_err)]
pub fn infer_pattern(
&mut self,
pattern: UntypedPattern,
@ -130,6 +133,7 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
self.unify(pattern, Rc::new(subject.clone()), None, false)
}
#[allow(clippy::result_large_err)]
/// When we have an assignment or a case expression we unify the pattern with the
/// inferred type of the subject in order to determine what variables to insert
/// into the environment (or to detect a type error).

6
crates/aiken-lang/src/tipo/pipe.rs
View File

@ -21,6 +21,7 @@ pub(crate) struct PipeTyper<'a, 'b, 'c> {
}
impl<'a, 'b, 'c> PipeTyper<'a, 'b, 'c> {
#[allow(clippy::result_large_err)]
pub fn infer(
expr_typer: &'a mut ExprTyper<'b, 'c>,
expressions: Vec1<UntypedExpr>,
@ -56,6 +57,7 @@ impl<'a, 'b, 'c> PipeTyper<'a, 'b, 'c> {
typer.infer_expressions(expressions)
}
#[allow(clippy::result_large_err)]
fn infer_expressions(
mut self,
expressions: impl IntoIterator<Item = UntypedExpr>,
@ -74,6 +76,7 @@ impl<'a, 'b, 'c> PipeTyper<'a, 'b, 'c> {
})
}
#[allow(clippy::result_large_err)]
fn infer_each_expression(
&mut self,
expressions: impl IntoIterator<Item = UntypedExpr>,
@ -192,6 +195,7 @@ impl<'a, 'b, 'c> PipeTyper<'a, 'b, 'c> {
}
/// Attempt to infer a |> b(..c) as b(..c)(a)
#[allow(clippy::result_large_err)]
fn infer_apply_to_call_pipe(
&mut self,
function: TypedExpr,
@ -225,6 +229,7 @@ impl<'a, 'b, 'c> PipeTyper<'a, 'b, 'c> {
}
/// Attempt to infer a |> b(c) as b(a, c)
#[allow(clippy::result_large_err)]
fn infer_insert_pipe(
&mut self,
function: TypedExpr,
@ -247,6 +252,7 @@ impl<'a, 'b, 'c> PipeTyper<'a, 'b, 'c> {
}
/// Attempt to infer a |> b as b(a)
#[allow(clippy::result_large_err)]
fn infer_apply_pipe(&mut self, func: UntypedExpr) -> Result<TypedExpr, Error> {
let func = Box::new(self.expr_typer.infer(func)?);
let return_type = self.expr_typer.new_unbound_var();

2
crates/aiken-lsp/src/cast.rs
View File

@ -1,5 +1,6 @@
use crate::error::Error;
#[allow(clippy::result_large_err)]
pub fn cast_request<R>(request: lsp_server::Request) -> Result<R::Params, Error>
where
R: lsp_types::request::Request,
@ -10,6 +11,7 @@ where
Ok(params)
}
#[allow(clippy::result_large_err)]
pub fn cast_notification<N>(notification: lsp_server::Notification) -> Result<N::Params, Error>
where
N: lsp_types::notification::Notification,

1
crates/aiken-lsp/src/lib.rs
View File

@ -11,6 +11,7 @@ mod quickfix;
pub mod server;
mod utils;
#[allow(clippy::result_large_err)]
pub fn start() -> Result<(), Error> {
tracing::info!("Aiken language server starting");

14
crates/aiken-lsp/src/server.rs
View File

@ -75,6 +75,7 @@ pub struct Server {
impl Server {
/// Clear all diagnostics that have been previously published to the client
#[allow(clippy::result_large_err)]
fn clear_all_diagnostics(&mut self, connection: &Connection) -> Result<(), ServerError> {
for file in self.published_diagnostics.drain() {
let params = lsp_types::PublishDiagnosticsParams {
@ -97,6 +98,7 @@ impl Server {
}
/// Compile the project if we are in one. Otherwise do nothing.
#[allow(clippy::result_large_err)]
fn compile(&mut self, connection: &Connection) -> Result<(), ServerError> {
self.notify_client_of_compilation_start(connection)?;
@ -119,6 +121,7 @@ impl Server {
Ok(())
}
#[allow(clippy::result_large_err)]
fn create_compilation_progress_token(
&mut self,
connection: &lsp_server::Connection,
@ -191,6 +194,7 @@ impl Server {
Ok(vec![text_edit_replace(new_text)])
}
#[allow(clippy::result_large_err)]
fn handle_notification(
&mut self,
connection: &lsp_server::Connection,
@ -251,6 +255,7 @@ impl Server {
}
}
#[allow(clippy::result_large_err)]
fn handle_request(
&mut self,
request: lsp_server::Request,
@ -434,6 +439,7 @@ impl Server {
Some(modules)
}
#[allow(clippy::result_large_err)]
fn goto_definition(
&self,
params: lsp_types::GotoDefinitionParams,
@ -500,6 +506,7 @@ impl Server {
})
}
#[allow(clippy::result_large_err)]
fn hover(
&self,
params: lsp_types::HoverParams,
@ -560,6 +567,7 @@ impl Server {
}))
}
#[allow(clippy::result_large_err)]
pub fn listen(&mut self, connection: Connection) -> Result<(), ServerError> {
self.create_compilation_progress_token(&connection)?;
self.start_watching_aiken_toml(&connection)?;
@ -614,6 +622,7 @@ impl Server {
server
}
#[allow(clippy::result_large_err)]
fn notify_client_of_compilation_end(&self, connection: &Connection) -> Result<(), ServerError> {
self.send_work_done_notification(
connection,
@ -621,6 +630,7 @@ impl Server {
)
}
#[allow(clippy::result_large_err)]
fn notify_client_of_compilation_start(
&self,
connection: &Connection,
@ -643,6 +653,7 @@ impl Server {
/// If the Aiken diagnostic cannot be converted to LSP diagnostic (due to it
/// not having a location) it is stored as a message suitable for use with
/// the `showMessage` notification instead.
#[allow(clippy::result_large_err)]
fn process_diagnostic<E>(&mut self, error: E) -> Result<(), ServerError>
where
E: Diagnostic + GetSource + ExtraData,
@ -730,6 +741,7 @@ impl Server {
/// Publish all stored diagnostics to the client.
/// Any previously publish diagnostics are cleared before the new set are
/// published to the client.
#[allow(clippy::result_large_err)]
fn publish_stored_diagnostics(&mut self, connection: &Connection) -> Result<(), ServerError> {
self.clear_all_diagnostics(connection)?;
@ -778,6 +790,7 @@ impl Server {
.push(diagnostic);
}
#[allow(clippy::result_large_err)]
fn send_work_done_notification(
&self,
connection: &Connection,
@ -802,6 +815,7 @@ impl Server {
Ok(())
}
#[allow(clippy::result_large_err)]
fn start_watching_aiken_toml(&mut self, connection: &Connection) -> Result<(), ServerError> {
let supports_watch_files = self
.initialize_params

7
crates/aiken-lsp/src/utils.rs
View File

@ -1,12 +1,10 @@
use std::path::{Path, PathBuf};
use crate::error::Error;
use aiken_lang::{ast::Span, line_numbers::LineNumbers};
use itertools::Itertools;
use lsp_types::TextEdit;
use std::path::{Path, PathBuf};
use urlencoding::decode;
use crate::error::Error;
pub const COMPILING_PROGRESS_TOKEN: &str = "compiling-aiken";
pub const CREATE_COMPILING_PROGRESS_TOKEN: &str = "create-compiling-progress-token";
@ -26,6 +24,7 @@ pub fn text_edit_replace(new_text: String) -> TextEdit {
}
}
#[allow(clippy::result_large_err)]
pub fn path_to_uri(path: PathBuf) -> Result<lsp_types::Url, Error> {
let mut file: String = "file://".into();

12
crates/uplc/src/tx/script_context.rs
View File

@ -407,7 +407,7 @@ impl TxInfo {
}
})
.map(move |purpose| ScriptContext::V1V2 {
tx_info: self,
tx_info: self.into(),
purpose: purpose.clone().into(),
}),
@ -421,9 +421,9 @@ impl TxInfo {
}
})
.map(move |purpose| ScriptContext::V3 {
tx_info: self,
tx_info: self.into(),
redeemer: redeemer.data.clone(),
purpose: purpose.clone().into_script_info(datum.cloned()),
purpose: purpose.clone().into_script_info(datum.cloned()).into(),
}),
}
}
@ -464,13 +464,13 @@ impl TxInfo {
#[derive(Debug, PartialEq, Clone)]
pub enum ScriptContext {
V1V2 {
tx_info: TxInfo,
tx_info: Box<TxInfo>,
purpose: Box<ScriptPurpose>,
},
V3 {
tx_info: TxInfo,
tx_info: Box<TxInfo>,
redeemer: PlutusData,
purpose: ScriptInfo<Option<PlutusData>>,
purpose: Box<ScriptInfo<Option<PlutusData>>>,
},
}

2
crates/uplc/src/tx/to_plutus_data.rs
View File

@ -1397,7 +1397,7 @@ impl ToPlutusData for ScriptContext {
vec![
tx_info.to_plutus_data(),
redeemer.to_plutus_data(),
WithNeverRegistrationDeposit(purpose).to_plutus_data(),
WithNeverRegistrationDeposit(purpose.as_ref()).to_plutus_data(),
],
),
}