language-servers/erg
1
0
Fork 0
mirror of https://github.com/erg-lang/erg.git synced 2025-10-03 05:54:33 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

chore: let HIRBuilder/ASTLowerer be generic

Browse source
This commit is contained in:
Shunsuke Shibayama 2023-11-03 03:03:11 +09:00
parent f4fcf3f2b2
commit 51c7b0778d
10 changed files with 126 additions and 75 deletions
Download patch file Download diff file Expand all files Collapse all files

4
crates/els/completion.rs
View file

@ -16,7 +16,7 @@ use erg_common::spawn::spawn_new_thread;
use erg_common::traits::Locational; use erg_common::traits::Locational;
use erg_compiler::artifact::{BuildRunnable, Buildable}; use erg_compiler::artifact::{BuildRunnable, Buildable};
use erg_compiler::build_package::PlainPackageBuilder; use erg_compiler::build_package::PackageBuilder;
use erg_compiler::context::Context; use erg_compiler::context::Context;
use erg_compiler::erg_parser::parse::Parsable; use erg_compiler::erg_parser::parse::Parsable;
use erg_compiler::erg_parser::token::TokenKind; use erg_compiler::erg_parser::token::TokenKind;
@ -326,7 +326,7 @@ fn load_modules<'a>(
..cfg ..cfg
}; };
let shared = SharedCompilerResource::new(cfg.clone()); let shared = SharedCompilerResource::new(cfg.clone());
let mut checker = PlainPackageBuilder::inherit(cfg, shared.clone()); let mut checker = PackageBuilder::inherit(cfg, shared.clone());
let _res = checker.build(src, "exec"); let _res = checker.build(src, "exec");
let mut cache = cache.borrow_mut(); let mut cache = cache.borrow_mut();
if cache.get("<module>").is_none() { if cache.get("<module>").is_none() {

36
crates/erg_compiler/build_hir.rs
View file

@ -5,14 +5,14 @@ use erg_common::traits::{ExitStatus, Runnable, Stream};
use erg_common::Str; use erg_common::Str;
use erg_parser::ast::{VarName, AST}; use erg_parser::ast::{VarName, AST};
use erg_parser::build_ast::ASTBuilder; use erg_parser::build_ast::{ASTBuildable, ASTBuilder as DefaultASTBuilder};
use crate::artifact::{BuildRunnable, Buildable, CompleteArtifact, IncompleteArtifact}; use crate::artifact::{BuildRunnable, Buildable, CompleteArtifact, IncompleteArtifact};
use crate::context::{Context, ContextKind, ContextProvider, ModuleContext}; use crate::context::{Context, ContextKind, ContextProvider, ModuleContext};
use crate::effectcheck::SideEffectChecker; use crate::effectcheck::SideEffectChecker;
use crate::error::{CompileError, CompileErrors, LowerWarnings}; use crate::error::{CompileError, CompileErrors, LowerWarnings};
use crate::link_hir::HIRLinker; use crate::link_hir::HIRLinker;
use crate::lower::ASTLowerer; use crate::lower::GenericASTLowerer;
use crate::module::SharedCompilerResource; use crate::module::SharedCompilerResource;
use crate::ownercheck::OwnershipChecker; use crate::ownercheck::OwnershipChecker;
use crate::ty::VisibilityModifier; use crate::ty::VisibilityModifier;
@ -22,24 +22,26 @@ use crate::varinfo::VarInfo;
/// ///
/// NOTE: This does not perform dependency resolution, use `PackageBuilder` to build a package /// NOTE: This does not perform dependency resolution, use `PackageBuilder` to build a package
#[derive(Debug)] #[derive(Debug)]
pub struct HIRBuilder { pub struct GenericHIRBuilder<ASTBuilder: ASTBuildable = DefaultASTBuilder> {
pub(crate) lowerer: ASTLowerer, pub(crate) lowerer: GenericASTLowerer<ASTBuilder>,
ownership_checker: OwnershipChecker, ownership_checker: OwnershipChecker,
} }
impl Default for HIRBuilder { pub type HIRBuilder = GenericHIRBuilder<DefaultASTBuilder>;
impl<ASTBuilder: ASTBuildable> Default for GenericHIRBuilder<ASTBuilder> {
fn default() -> Self { fn default() -> Self {
HIRBuilder::new(ErgConfig::default()) GenericHIRBuilder::new(ErgConfig::default())
} }
} }
impl Runnable for HIRBuilder { impl<ASTBuilder: ASTBuildable> Runnable for GenericHIRBuilder<ASTBuilder> {
type Err = CompileError; type Err = CompileError;
type Errs = CompileErrors; type Errs = CompileErrors;
const NAME: &'static str = "Erg HIR builder"; const NAME: &'static str = "Erg HIR builder";
fn new(cfg: ErgConfig) -> Self { fn new(cfg: ErgConfig) -> Self {
HIRBuilder::new_with_cache( GenericHIRBuilder::new_with_cache(
cfg.copy(), cfg.copy(),
Str::ever("<module>"), Str::ever("<module>"),
SharedCompilerResource::new(cfg), SharedCompilerResource::new(cfg),
@ -71,7 +73,7 @@ impl Runnable for HIRBuilder {
fn exec(&mut self) -> Result<ExitStatus, Self::Errs> { fn exec(&mut self) -> Result<ExitStatus, Self::Errs> {
let mut builder = ASTBuilder::new(self.cfg().copy()); let mut builder = ASTBuilder::new(self.cfg().copy());
let artifact = builder let artifact = builder
.build(self.cfg_mut().input.read()) .build_ast(self.cfg_mut().input.read())
.map_err(|arti| arti.errors)?; .map_err(|arti| arti.errors)?;
artifact.warns.write_all_stderr(); artifact.warns.write_all_stderr();
let artifact = self let artifact = self
@ -84,7 +86,7 @@ impl Runnable for HIRBuilder {
fn eval(&mut self, src: String) -> Result<String, Self::Errs> { fn eval(&mut self, src: String) -> Result<String, Self::Errs> {
let mut builder = ASTBuilder::new(self.cfg().copy()); let mut builder = ASTBuilder::new(self.cfg().copy());
let artifact = builder.build(src).map_err(|arti| arti.errors)?; let artifact = builder.build_ast(src).map_err(|arti| arti.errors)?;
artifact.warns.write_all_stderr(); artifact.warns.write_all_stderr();
let artifact = self let artifact = self
.check(artifact.ast, "eval") .check(artifact.ast, "eval")
@ -94,7 +96,7 @@ impl Runnable for HIRBuilder {
} }
} }
impl Buildable for HIRBuilder { impl<ASTBuilder: ASTBuildable> Buildable for GenericHIRBuilder<ASTBuilder> {
fn inherit(cfg: ErgConfig, shared: SharedCompilerResource) -> Self { fn inherit(cfg: ErgConfig, shared: SharedCompilerResource) -> Self {
let mod_name = Str::from(cfg.input.file_stem()); let mod_name = Str::from(cfg.input.file_stem());
Self::new_with_cache(cfg, mod_name, shared) Self::new_with_cache(cfg, mod_name, shared)
@ -120,9 +122,9 @@ impl Buildable for HIRBuilder {
} }
} }
impl BuildRunnable for HIRBuilder {} impl<ASTBuilder: ASTBuildable + 'static> BuildRunnable for GenericHIRBuilder<ASTBuilder> {}
impl ContextProvider for HIRBuilder { impl<ASTBuilder: ASTBuildable> ContextProvider for GenericHIRBuilder<ASTBuilder> {
fn dir(&self) -> Dict<&VarName, &VarInfo> { fn dir(&self) -> Dict<&VarName, &VarInfo> {
self.lowerer.dir() self.lowerer.dir()
} }
@ -136,14 +138,14 @@ impl ContextProvider for HIRBuilder {
} }
} }
impl HIRBuilder { impl<ASTBuilder: ASTBuildable> GenericHIRBuilder<ASTBuilder> {
pub fn new_with_cache<S: Into<Str>>( pub fn new_with_cache<S: Into<Str>>(
cfg: ErgConfig, cfg: ErgConfig,
mod_name: S, mod_name: S,
shared: SharedCompilerResource, shared: SharedCompilerResource,
) -> Self { ) -> Self {
Self { Self {
lowerer: ASTLowerer::new_with_cache(cfg.copy(), mod_name, shared), lowerer: GenericASTLowerer::new_with_cache(cfg.copy(), mod_name, shared),
ownership_checker: OwnershipChecker::new(cfg), ownership_checker: OwnershipChecker::new(cfg),
} }
} }
@ -157,7 +159,7 @@ impl HIRBuilder {
); );
Self { Self {
ownership_checker: OwnershipChecker::new(mod_ctx.get_top_cfg()), ownership_checker: OwnershipChecker::new(mod_ctx.get_top_cfg()),
lowerer: ASTLowerer::new_with_ctx(mod_ctx), lowerer: GenericASTLowerer::new_with_ctx(mod_ctx),
} }
} }
@ -184,7 +186,7 @@ impl HIRBuilder {
) -> Result<CompleteArtifact, IncompleteArtifact> { ) -> Result<CompleteArtifact, IncompleteArtifact> {
let mut ast_builder = ASTBuilder::new(self.cfg().copy()); let mut ast_builder = ASTBuilder::new(self.cfg().copy());
let artifact = ast_builder let artifact = ast_builder
.build(src) .build_ast(src)
.map_err(|iart| IncompleteArtifact::new(None, iart.errors.into(), iart.warns.into()))?; .map_err(|iart| IncompleteArtifact::new(None, iart.errors.into(), iart.warns.into()))?;
self.lowerer self.lowerer
.warns .warns

85
crates/erg_compiler/build_package.rs
View file

@ -15,7 +15,7 @@ use erg_common::str::Str;
use erg_common::traits::{ExitStatus, Runnable, Stream}; use erg_common::traits::{ExitStatus, Runnable, Stream};
use erg_parser::ast::{Expr, InlineModule, VarName, AST}; use erg_parser::ast::{Expr, InlineModule, VarName, AST};
use erg_parser::build_ast::{ASTBuildable, ASTBuilder}; use erg_parser::build_ast::{ASTBuildable, ASTBuilder as DefaultASTBuilder};
use erg_parser::parse::SimpleParser; use erg_parser::parse::SimpleParser;
use crate::artifact::{ use crate::artifact::{
@ -23,11 +23,11 @@ use crate::artifact::{
}; };
use crate::context::{Context, ContextProvider, ModuleContext}; use crate::context::{Context, ContextProvider, ModuleContext};
use crate::error::{CompileError, CompileErrors}; use crate::error::{CompileError, CompileErrors};
use crate::lower::ASTLowerer; use crate::lower::GenericASTLowerer;
use crate::module::SharedCompilerResource; use crate::module::SharedCompilerResource;
use crate::ty::ValueObj; use crate::ty::ValueObj;
use crate::varinfo::VarInfo; use crate::varinfo::VarInfo;
use crate::HIRBuilder; use crate::GenericHIRBuilder;
#[derive(Debug)] #[derive(Debug)]
pub enum ResolveError { pub enum ResolveError {
@ -45,35 +45,42 @@ pub type ResolveResult<T> = Result<T, ResolveError>;
/// Invariant condition: `build_module` must be idempotent. /// Invariant condition: `build_module` must be idempotent.
/// That is, the only thing that may differ as a result of analyzing the same package is the elapsed time. /// That is, the only thing that may differ as a result of analyzing the same package is the elapsed time.
#[derive(Debug)] #[derive(Debug)]
pub struct PackageBuilder<Parser: ASTBuildable = ASTBuilder, Builder: Buildable = HIRBuilder> { pub struct GenericPackageBuilder<
ASTBuilder: ASTBuildable = DefaultASTBuilder,
HIRBuilder: Buildable = GenericHIRBuilder,
> {
cfg: ErgConfig, cfg: ErgConfig,
shared: SharedCompilerResource, shared: SharedCompilerResource,
pub(crate) main_builder: Builder, pub(crate) main_builder: HIRBuilder,
cyclic: Vec<NormalizedPathBuf>, cyclic: Vec<NormalizedPathBuf>,
submodules: Vec<NormalizedPathBuf>, submodules: Vec<NormalizedPathBuf>,
asts: Dict<NormalizedPathBuf, (Str, AST)>, asts: Dict<NormalizedPathBuf, (Str, AST)>,
parse_errors: ErrorArtifact, parse_errors: ErrorArtifact,
_parser: PhantomData<fn() -> Parser>, _parser: PhantomData<fn() -> ASTBuilder>,
} }
pub type PlainPackageBuilder = PackageBuilder<ASTBuilder, HIRBuilder>; pub type PackageBuilder = GenericPackageBuilder<DefaultASTBuilder, GenericHIRBuilder>;
pub type PackageTypeChecker = PackageBuilder<ASTBuilder, ASTLowerer>; pub type PackageTypeChecker =
pub type FullPackageBuilder = PackageBuilder<ASTBuilder, HIRBuilder>; GenericPackageBuilder<DefaultASTBuilder, GenericASTLowerer<DefaultASTBuilder>>;
impl<Parser: ASTBuildable, Builder: Buildable> Default for PackageBuilder<Parser, Builder> { impl<ASTBuilder: ASTBuildable, HIRBuilder: Buildable> Default
for GenericPackageBuilder<ASTBuilder, HIRBuilder>
{
fn default() -> Self { fn default() -> Self {
let cfg = ErgConfig::default(); let cfg = ErgConfig::default();
PackageBuilder::new(cfg.copy(), SharedCompilerResource::new(cfg)) GenericPackageBuilder::new(cfg.copy(), SharedCompilerResource::new(cfg))
} }
} }
impl<Parser: ASTBuildable, Builder: BuildRunnable> Runnable for PackageBuilder<Parser, Builder> { impl<ASTBuilder: ASTBuildable, HIRBuilder: BuildRunnable> Runnable
for GenericPackageBuilder<ASTBuilder, HIRBuilder>
{
type Err = CompileError; type Err = CompileError;
type Errs = CompileErrors; type Errs = CompileErrors;
const NAME: &'static str = "Erg package builder"; const NAME: &'static str = "Erg package builder";
fn new(cfg: ErgConfig) -> Self { fn new(cfg: ErgConfig) -> Self {
PackageBuilder::new(cfg.copy(), SharedCompilerResource::new(cfg)) GenericPackageBuilder::new(cfg.copy(), SharedCompilerResource::new(cfg))
} }
#[inline] #[inline]
@ -114,7 +121,9 @@ impl<Parser: ASTBuildable, Builder: BuildRunnable> Runnable for PackageBuilder<P
} }
} }
impl<Parser: ASTBuildable, Builder: Buildable> Buildable for PackageBuilder<Parser, Builder> { impl<ASTBuilder: ASTBuildable, HIRBuilder: Buildable> Buildable
for GenericPackageBuilder<ASTBuilder, HIRBuilder>
{
fn inherit(cfg: ErgConfig, shared: SharedCompilerResource) -> Self { fn inherit(cfg: ErgConfig, shared: SharedCompilerResource) -> Self {
let mod_name = Str::from(cfg.input.file_stem()); let mod_name = Str::from(cfg.input.file_stem());
Self::new_with_cache(cfg, mod_name, shared) Self::new_with_cache(cfg, mod_name, shared)
@ -140,13 +149,13 @@ impl<Parser: ASTBuildable, Builder: Buildable> Buildable for PackageBuilder<Pars
} }
} }
impl<Parser: ASTBuildable + 'static, Builder: BuildRunnable + 'static> BuildRunnable impl<ASTBuilder: ASTBuildable + 'static, HIRBuilder: BuildRunnable + 'static> BuildRunnable
for PackageBuilder<Parser, Builder> for GenericPackageBuilder<ASTBuilder, HIRBuilder>
{ {
} }
impl<Parser: ASTBuildable, Builder: Buildable + ContextProvider> ContextProvider impl<ASTBuilder: ASTBuildable, HIRBuilder: Buildable + ContextProvider> ContextProvider
for PackageBuilder<Parser, Builder> for GenericPackageBuilder<ASTBuilder, HIRBuilder>
{ {
fn dir(&self) -> Dict<&VarName, &VarInfo> { fn dir(&self) -> Dict<&VarName, &VarInfo> {
self.main_builder.dir() self.main_builder.dir()
@ -161,7 +170,9 @@ impl<Parser: ASTBuildable, Builder: Buildable + ContextProvider> ContextProvider
} }
} }
impl<Parser: ASTBuildable, Builder: Buildable> PackageBuilder<Parser, Builder> { impl<ASTBuilder: ASTBuildable, HIRBuilder: Buildable>
GenericPackageBuilder<ASTBuilder, HIRBuilder>
{
pub fn new(cfg: ErgConfig, shared: SharedCompilerResource) -> Self { pub fn new(cfg: ErgConfig, shared: SharedCompilerResource) -> Self {
Self::new_with_cache(cfg, "<module>".into(), shared) Self::new_with_cache(cfg, "<module>".into(), shared)
} }
@ -173,7 +184,7 @@ impl<Parser: ASTBuildable, Builder: Buildable> PackageBuilder<Parser, Builder> {
Self { Self {
cfg: cfg.copy(), cfg: cfg.copy(),
shared: shared.clone(), shared: shared.clone(),
main_builder: Builder::inherit_with_name(cfg, mod_name, shared), main_builder: HIRBuilder::inherit_with_name(cfg, mod_name, shared),
cyclic: vec![], cyclic: vec![],
submodules: vec![], submodules: vec![],
asts: Dict::new(), asts: Dict::new(),
@ -187,7 +198,7 @@ impl<Parser: ASTBuildable, Builder: Buildable> PackageBuilder<Parser, Builder> {
src: String, src: String,
mode: &str, mode: &str,
) -> Result<CompleteArtifact, IncompleteArtifact> { ) -> Result<CompleteArtifact, IncompleteArtifact> {
let mut ast_builder = Parser::new(self.cfg.copy()); let mut ast_builder = ASTBuilder::new(self.cfg.copy());
let artifact = ast_builder let artifact = ast_builder
.build_ast(src) .build_ast(src)
.map_err(|err| IncompleteArtifact::new(None, err.errors.into(), err.warns.into()))?; .map_err(|err| IncompleteArtifact::new(None, err.errors.into(), err.warns.into()))?;
@ -242,6 +253,20 @@ impl<Parser: ASTBuildable, Builder: Buildable> PackageBuilder<Parser, Builder> {
} }
} }
} }
Expr::Dummy(chunks) => {
for chunk in chunks.iter_mut() {
if let Err(err) = self.check_import(chunk, cfg) {
result = Err(err);
}
}
}
Expr::Compound(chunks) => {
for chunk in chunks.iter_mut() {
if let Err(err) = self.check_import(chunk, cfg) {
result = Err(err);
}
}
}
_ => {} _ => {}
} }
result result
@ -284,7 +309,7 @@ impl<Parser: ASTBuildable, Builder: Buildable> PackageBuilder<Parser, Builder> {
}; };
let import_path = NormalizedPathBuf::from(import_path.clone()); let import_path = NormalizedPathBuf::from(import_path.clone());
self.shared.graph.add_node_if_none(&import_path); self.shared.graph.add_node_if_none(&import_path);
let mut ast_builder = Parser::new(cfg.copy()); let mut ast_builder = ASTBuilder::new(cfg.copy());
let mut ast = match ast_builder.build_ast(src) { let mut ast = match ast_builder.build_ast(src) {
Ok(art) => { Ok(art) => {
self.parse_errors self.parse_errors
@ -397,19 +422,19 @@ impl<Parser: ASTBuildable, Builder: Buildable> PackageBuilder<Parser, Builder> {
return; return;
} }
let run = move || { let run = move || {
let mut builder = HIRBuilder::new_with_cache(cfg, name, shared.clone()); let mut builder = HIRBuilder::inherit_with_name(cfg, name, shared.clone());
let cache = if mode == "exec" { let cache = if mode == "exec" {
&shared.mod_cache &shared.mod_cache
} else { } else {
&shared.py_mod_cache &shared.py_mod_cache
}; };
match builder.check(ast, mode) { match builder.build_from_ast(ast, mode) {
Ok(artifact) => { Ok(artifact) => {
cache.register( cache.register(
_path.clone(), _path.clone(),
raw_ast, raw_ast,
Some(artifact.object), Some(artifact.object),
builder.pop_mod_ctx().unwrap(), builder.pop_context().unwrap(),
); );
shared.warns.extend(artifact.warns); shared.warns.extend(artifact.warns);
} }
@ -418,7 +443,7 @@ impl<Parser: ASTBuildable, Builder: Buildable> PackageBuilder<Parser, Builder> {
_path.clone(), _path.clone(),
raw_ast, raw_ast,
artifact.object, artifact.object,
builder.pop_mod_ctx().unwrap(), builder.pop_context().unwrap(),
); );
shared.warns.extend(artifact.warns); shared.warns.extend(artifact.warns);
shared.errors.extend(artifact.errors); shared.errors.extend(artifact.errors);
@ -463,15 +488,15 @@ impl<Parser: ASTBuildable, Builder: Buildable> PackageBuilder<Parser, Builder> {
None None
}; };
let mut builder = let mut builder =
HIRBuilder::new_with_cache(cfg, self.mod_name(&path), self.shared.clone()); HIRBuilder::inherit_with_name(cfg, self.mod_name(&path), self.shared.clone());
match builder.check(ast, "declare") { match builder.build_from_ast(ast, "declare") {
Ok(artifact) => { Ok(artifact) => {
let ctx = builder.pop_mod_ctx().unwrap(); let ctx = builder.pop_context().unwrap();
py_mod_cache.register(path.clone(), raw_ast, Some(artifact.object), ctx); py_mod_cache.register(path.clone(), raw_ast, Some(artifact.object), ctx);
self.shared.warns.extend(artifact.warns); self.shared.warns.extend(artifact.warns);
} }
Err(artifact) => { Err(artifact) => {
let ctx = builder.pop_mod_ctx().unwrap(); let ctx = builder.pop_context().unwrap();
py_mod_cache.register(path, raw_ast, artifact.object, ctx); py_mod_cache.register(path, raw_ast, artifact.object, ctx);
self.shared.warns.extend(artifact.warns); self.shared.warns.extend(artifact.warns);
self.shared.errors.extend(artifact.errors); self.shared.errors.extend(artifact.errors);

5
crates/erg_compiler/declare.rs
View file

@ -5,11 +5,12 @@ use erg_common::traits::{Locational, Runnable, Stream};
use erg_common::{enum_unwrap, fn_name, log, set, Str, Triple}; use erg_common::{enum_unwrap, fn_name, log, set, Str, Triple};
use erg_parser::ast::{self, AscriptionKind, DefId, Identifier, TypeAppArgsKind, VarName, AST}; use erg_parser::ast::{self, AscriptionKind, DefId, Identifier, TypeAppArgsKind, VarName, AST};
use erg_parser::build_ast::ASTBuildable;
use erg_parser::desugar::Desugarer; use erg_parser::desugar::Desugarer;
use crate::context::instantiate::TyVarCache; use crate::context::instantiate::TyVarCache;
use crate::context::{ClassDefType, Context, MethodContext, MethodPair, TraitImpl}; use crate::context::{ClassDefType, Context, MethodContext, MethodPair, TraitImpl};
use crate::lower::ASTLowerer; use crate::lower::GenericASTLowerer;
use crate::ty::constructors::{array_t, mono, mono_q_tp, poly, v_enum}; use crate::ty::constructors::{array_t, mono, mono_q_tp, poly, v_enum};
use crate::ty::free::{Constraint, HasLevel}; use crate::ty::free::{Constraint, HasLevel};
use crate::ty::value::{GenTypeObj, TypeObj, ValueObj}; use crate::ty::value::{GenTypeObj, TypeObj, ValueObj};
@ -21,7 +22,7 @@ use crate::hir::HIR;
use crate::varinfo::{Mutability, VarInfo, VarKind}; use crate::varinfo::{Mutability, VarInfo, VarKind};
use crate::{feature_error, hir}; use crate::{feature_error, hir};
impl ASTLowerer { impl<A: ASTBuildable> GenericASTLowerer<A> {
fn declare_var( fn declare_var(
&mut self, &mut self,
sig: ast::VarSignature, sig: ast::VarSignature,

15
crates/erg_compiler/error/mod.rs
View file

@ -186,6 +186,15 @@ impl From<ParserRunnerError> for CompileError {
} }
} }
impl From<CompileError> for ParserRunnerError {
fn from(err: CompileError) -> Self {
Self {
core: *err.core,
input: err.input,
}
}
}
impl ErrorDisplay for CompileError { impl ErrorDisplay for CompileError {
fn core(&self) -> &ErrorCore { fn core(&self) -> &ErrorCore {
&self.core &self.core
@ -512,6 +521,12 @@ impl From<ParserRunnerErrors> for CompileErrors {
} }
} }
impl From<CompileErrors> for ParserRunnerErrors {
fn from(err: CompileErrors) -> Self {
Self::new(err.into_iter().map(|e| e.into()).collect())
}
}
impl From<Vec<CompileError>> for CompileErrors { impl From<Vec<CompileError>> for CompileErrors {
fn from(errs: Vec<CompileError>) -> Self { fn from(errs: Vec<CompileError>) -> Self {
Self(errs) Self(errs)

2
crates/erg_compiler/lib.rs
View file

@ -27,6 +27,6 @@ pub mod transpile;
pub mod ty; pub mod ty;
pub mod varinfo; pub mod varinfo;
pub use build_hir::HIRBuilder; pub use build_hir::{GenericHIRBuilder, HIRBuilder};
pub use erg_parser::build_ast::ASTBuilder; pub use erg_parser::build_ast::ASTBuilder;
pub use transpile::Transpiler; pub use transpile::Transpiler;

8
crates/erg_compiler/lint.rs
View file

@ -8,7 +8,7 @@ use erg_common::pathutil::NormalizedPathBuf;
use erg_common::traits::{Locational, Runnable, Stream}; use erg_common::traits::{Locational, Runnable, Stream};
use erg_common::Str; use erg_common::Str;
use erg_parser::ast::AST; use erg_parser::ast::AST;
use erg_parser::build_ast::ASTBuilder; use erg_parser::build_ast::ASTBuildable;
use erg_parser::lex::Lexer; use erg_parser::lex::Lexer;
use crate::context::ContextKind; use crate::context::ContextKind;
@ -19,10 +19,10 @@ use crate::error::{
CompileErrors, LowerError, LowerResult, LowerWarning, LowerWarnings, SingleLowerResult, CompileErrors, LowerError, LowerResult, LowerWarning, LowerWarnings, SingleLowerResult,
}; };
use crate::hir::{self, Expr, Signature, HIR}; use crate::hir::{self, Expr, Signature, HIR};
use crate::lower::ASTLowerer; use crate::lower::GenericASTLowerer;
use crate::varinfo::VarInfo; use crate::varinfo::VarInfo;
impl ASTLowerer { impl<ASTBuilder: ASTBuildable> GenericASTLowerer<ASTBuilder> {
pub(crate) fn var_result_t_check( pub(crate) fn var_result_t_check(
&self, &self,
loc: &impl Locational, loc: &impl Locational,
@ -221,7 +221,7 @@ impl ASTLowerer {
} else { } else {
format!("{}{code}", "\n".repeat(first_line as usize)) format!("{}{code}", "\n".repeat(first_line as usize))
}; };
match ASTBuilder::new(self.cfg().clone()).build(code) { match ASTBuilder::new(self.cfg().clone()).build_ast(code) {
Ok(artifact) => { Ok(artifact) => {
self.check_doc_ast(artifact.ast); self.check_doc_ast(artifact.ast);
} }

38
crates/erg_compiler/lower.rs
View file

@ -1,6 +1,7 @@
//! implements `ASTLowerer`. //! implements `ASTLowerer`.
//! //!
//! ASTLowerer(ASTからHIRへの変換器)を実装 //! ASTLowerer(ASTからHIRへの変換器)を実装
use std::marker::PhantomData;
use std::mem; use std::mem;
use std::path::Path; use std::path::Path;
@ -19,7 +20,7 @@ use erg_common::{fmt_option, fn_name, log, switch_lang, Str};
use erg_parser::ast::{self, AscriptionKind, DefId, InlineModule, VisModifierSpec}; use erg_parser::ast::{self, AscriptionKind, DefId, InlineModule, VisModifierSpec};
use erg_parser::ast::{OperationKind, TypeSpecWithOp, VarName, AST}; use erg_parser::ast::{OperationKind, TypeSpecWithOp, VarName, AST};
use erg_parser::build_ast::ASTBuilder; use erg_parser::build_ast::{ASTBuildable, ASTBuilder as DefaultASTBuilder};
use erg_parser::desugar::Desugarer; use erg_parser::desugar::Desugarer;
use erg_parser::token::{Token, TokenKind}; use erg_parser::token::{Token, TokenKind};
use erg_parser::Parser; use erg_parser::Parser;
@ -45,12 +46,12 @@ use crate::error::{
CompileError, CompileErrors, CompileWarning, LowerError, LowerErrors, LowerResult, CompileError, CompileErrors, CompileWarning, LowerError, LowerErrors, LowerResult,
LowerWarning, LowerWarnings, SingleLowerResult, LowerWarning, LowerWarnings, SingleLowerResult,
}; };
use crate::hir;
use crate::hir::HIR; use crate::hir::HIR;
use crate::link_ast::ASTLinker; use crate::link_ast::ASTLinker;
use crate::varinfo::{VarInfo, VarKind}; use crate::varinfo::{VarInfo, VarKind};
use crate::AccessKind;
use crate::{feature_error, unreachable_error}; use crate::{feature_error, unreachable_error};
use crate::{hir, HIRBuilder}; use crate::{AccessKind, GenericHIRBuilder};
use VisibilityModifier::*; use VisibilityModifier::*;
@ -66,15 +67,18 @@ pub fn expr_to_cast_target(expr: &ast::Expr) -> CastTarget {
/// Checks & infers types of an AST, and convert (lower) it into a HIR /// Checks & infers types of an AST, and convert (lower) it into a HIR
#[derive(Debug)] #[derive(Debug)]
pub struct ASTLowerer { pub struct GenericASTLowerer<ASTBuilder: ASTBuildable = DefaultASTBuilder> {
pub(crate) cfg: ErgConfig, pub(crate) cfg: ErgConfig,
pub(crate) module: ModuleContext, pub(crate) module: ModuleContext,
pub(crate) errs: LowerErrors, pub(crate) errs: LowerErrors,
pub(crate) warns: LowerWarnings, pub(crate) warns: LowerWarnings,
fresh_gen: FreshNameGenerator, fresh_gen: FreshNameGenerator,
_parser: PhantomData<fn() -> ASTBuilder>,
} }
impl Default for ASTLowerer { pub type ASTLowerer = GenericASTLowerer<DefaultASTBuilder>;
impl<A: ASTBuildable> Default for GenericASTLowerer<A> {
fn default() -> Self { fn default() -> Self {
Self::new_with_cache( Self::new_with_cache(
ErgConfig::default(), ErgConfig::default(),
@ -84,7 +88,7 @@ impl Default for ASTLowerer {
} }
} }
impl Runnable for ASTLowerer { impl<ASTBuilder: ASTBuildable> Runnable for GenericASTLowerer<ASTBuilder> {
type Err = CompileError; type Err = CompileError;
type Errs = CompileErrors; type Errs = CompileErrors;
const NAME: &'static str = "Erg lowerer"; const NAME: &'static str = "Erg lowerer";
@ -123,7 +127,7 @@ impl Runnable for ASTLowerer {
fn exec(&mut self) -> Result<ExitStatus, Self::Errs> { fn exec(&mut self) -> Result<ExitStatus, Self::Errs> {
let mut ast_builder = ASTBuilder::new(self.cfg.copy()); let mut ast_builder = ASTBuilder::new(self.cfg.copy());
let artifact = ast_builder let artifact = ast_builder
.build(self.cfg.input.read()) .build_ast(self.cfg.input.read())
.map_err(|artifact| artifact.errors)?; .map_err(|artifact| artifact.errors)?;
artifact.warns.write_all_to(&mut self.cfg.output); artifact.warns.write_all_to(&mut self.cfg.output);
let artifact = self let artifact = self
@ -137,7 +141,9 @@ impl Runnable for ASTLowerer {
fn eval(&mut self, src: String) -> Result<String, Self::Errs> { fn eval(&mut self, src: String) -> Result<String, Self::Errs> {
let mut ast_builder = ASTBuilder::new(self.cfg.copy()); let mut ast_builder = ASTBuilder::new(self.cfg.copy());
let artifact = ast_builder.build(src).map_err(|artifact| artifact.errors)?; let artifact = ast_builder
.build_ast(src)
.map_err(|artifact| artifact.errors)?;
artifact.warns.write_all_stderr(); artifact.warns.write_all_stderr();
let artifact = self let artifact = self
.lower(artifact.ast, "eval") .lower(artifact.ast, "eval")
@ -147,7 +153,7 @@ impl Runnable for ASTLowerer {
} }
} }
impl ContextProvider for ASTLowerer { impl<A: ASTBuildable> ContextProvider for GenericASTLowerer<A> {
fn dir(&self) -> Dict<&VarName, &VarInfo> { fn dir(&self) -> Dict<&VarName, &VarInfo> {
self.module.context.dir() self.module.context.dir()
} }
@ -161,7 +167,7 @@ impl ContextProvider for ASTLowerer {
} }
} }
impl Buildable for ASTLowerer { impl<ASTBuilder: ASTBuildable> Buildable for GenericASTLowerer<ASTBuilder> {
fn inherit(cfg: ErgConfig, shared: SharedCompilerResource) -> Self { fn inherit(cfg: ErgConfig, shared: SharedCompilerResource) -> Self {
let mod_name = Str::from(cfg.input.file_stem()); let mod_name = Str::from(cfg.input.file_stem());
Self::new_with_cache(cfg, mod_name, shared) Self::new_with_cache(cfg, mod_name, shared)
@ -177,7 +183,7 @@ impl Buildable for ASTLowerer {
mode: &str, mode: &str,
) -> Result<CompleteArtifact<HIR>, IncompleteArtifact<HIR>> { ) -> Result<CompleteArtifact<HIR>, IncompleteArtifact<HIR>> {
let mut ast_builder = ASTBuilder::new(self.cfg.copy()); let mut ast_builder = ASTBuilder::new(self.cfg.copy());
let artifact = ast_builder.build(src).map_err(|artifact| { let artifact = ast_builder.build_ast(src).map_err(|artifact| {
IncompleteArtifact::new(None, artifact.errors.into(), artifact.warns.into()) IncompleteArtifact::new(None, artifact.errors.into(), artifact.warns.into())
})?; })?;
self.lower(artifact.ast, mode) self.lower(artifact.ast, mode)
@ -199,9 +205,9 @@ impl Buildable for ASTLowerer {
} }
} }
impl BuildRunnable for ASTLowerer {} impl<A: ASTBuildable + 'static> BuildRunnable for GenericASTLowerer<A> {}
impl ASTLowerer { impl<ASTBuilder: ASTBuildable> GenericASTLowerer<ASTBuilder> {
pub fn new_with_cache<S: Into<Str>>( pub fn new_with_cache<S: Into<Str>>(
cfg: ErgConfig, cfg: ErgConfig,
mod_name: S, mod_name: S,
@ -215,6 +221,7 @@ impl ASTLowerer {
errs: LowerErrors::empty(), errs: LowerErrors::empty(),
warns: LowerWarnings::empty(), warns: LowerWarnings::empty(),
fresh_gen: FreshNameGenerator::new("lower"), fresh_gen: FreshNameGenerator::new("lower"),
_parser: PhantomData,
} }
} }
@ -225,6 +232,7 @@ impl ASTLowerer {
errs: LowerErrors::empty(), errs: LowerErrors::empty(),
warns: LowerWarnings::empty(), warns: LowerWarnings::empty(),
fresh_gen: FreshNameGenerator::new("lower"), fresh_gen: FreshNameGenerator::new("lower"),
_parser: PhantomData,
} }
} }
@ -266,7 +274,7 @@ impl ASTLowerer {
} }
} }
impl ASTLowerer { impl<A: ASTBuildable> GenericASTLowerer<A> {
pub(crate) fn lower_literal( pub(crate) fn lower_literal(
&mut self, &mut self,
lit: ast::Literal, lit: ast::Literal,
@ -2893,7 +2901,7 @@ impl ASTLowerer {
}; };
let parent = self.get_mod_ctx().context.get_module().unwrap().clone(); let parent = self.get_mod_ctx().context.get_module().unwrap().clone();
let mod_ctx = ModuleContext::new(parent, dict! {}); let mod_ctx = ModuleContext::new(parent, dict! {});
let mut builder = HIRBuilder::new_with_ctx(mod_ctx); let mut builder = GenericHIRBuilder::<A>::new_with_ctx(mod_ctx);
builder.lowerer.module.context.cfg.input = inline.input.clone(); builder.lowerer.module.context.cfg.input = inline.input.clone();
builder.cfg_mut().input = inline.input.clone(); builder.cfg_mut().input = inline.input.clone();
let mode = if path.to_string_lossy().ends_with("d.er") { let mode = if path.to_string_lossy().ends_with("d.er") {

4
crates/erg_compiler/main.rs
View file

@ -6,7 +6,7 @@ use erg_common::config::{ErgConfig, ErgMode::*};
use erg_common::spawn::exec_new_thread; use erg_common::spawn::exec_new_thread;
use erg_common::traits::{ExitStatus, Runnable}; use erg_common::traits::{ExitStatus, Runnable};
use erg_compiler::build_package::{FullPackageBuilder, PackageTypeChecker}; use erg_compiler::build_package::{PackageBuilder, PackageTypeChecker};
use erg_compiler::transpile::Transpiler; use erg_compiler::transpile::Transpiler;
use erg_compiler::ty::deserialize::Deserializer; use erg_compiler::ty::deserialize::Deserializer;
use erg_compiler::Compiler; use erg_compiler::Compiler;
@ -20,7 +20,7 @@ fn run() {
Lex => LexerRunner::run(cfg), Lex => LexerRunner::run(cfg),
Parse => ParserRunner::run(cfg), Parse => ParserRunner::run(cfg),
TypeCheck => PackageTypeChecker::run(cfg), TypeCheck => PackageTypeChecker::run(cfg),
FullCheck => FullPackageBuilder::run(cfg), FullCheck => PackageBuilder::run(cfg),
Transpile => Transpiler::run(cfg), Transpile => Transpiler::run(cfg),
Compile | Execute => Compiler::run(cfg), Compile | Execute => Compiler::run(cfg),
Read => Deserializer::run(cfg), Read => Deserializer::run(cfg),

4
src/main.rs
View file

@ -6,7 +6,7 @@ use erg_common::config::{ErgConfig, ErgMode::*};
use erg_common::spawn::exec_new_thread; use erg_common::spawn::exec_new_thread;
use erg_common::traits::{ExitStatus, Runnable}; use erg_common::traits::{ExitStatus, Runnable};
use erg_compiler::build_package::{FullPackageBuilder, PackageTypeChecker}; use erg_compiler::build_package::{PackageBuilder, PackageTypeChecker};
use erg_parser::lex::LexerRunner; use erg_parser::lex::LexerRunner;
use erg_parser::ParserRunner; use erg_parser::ParserRunner;
@ -23,7 +23,7 @@ fn run() {
Parse => ParserRunner::run(cfg), Parse => ParserRunner::run(cfg),
Desugar => ASTBuilder::run(cfg), Desugar => ASTBuilder::run(cfg),
TypeCheck => PackageTypeChecker::run(cfg), TypeCheck => PackageTypeChecker::run(cfg),
FullCheck => FullPackageBuilder::run(cfg), FullCheck => PackageBuilder::run(cfg),
Compile => Compiler::run(cfg), Compile => Compiler::run(cfg),
Transpile => Transpiler::run(cfg), Transpile => Transpiler::run(cfg),
Execute => DummyVM::run(cfg), Execute => DummyVM::run(cfg),