DOOME1M8Cover/comline
1
1
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Started codegen work for a few languages, more interpretation changes, and overall work

Browse source
This commit is contained in:
DOOM1EM8Cover 2023-09-01 04:14:35 +01:00
parent eef6a218f8
commit fc6686a2a1
51 changed files with 1250 additions and 651 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
core/Cargo.toml
View file

@ -19,7 +19,7 @@ semver = "1.0.18"
blake3 = "1.4.1"
lz4_flex = "0.11.1"
lex = "0.6.0"
snafu = "0.7.5"
snafu = { version = "0.7.5", features = ["guide"] }
strum_macros = "0.25.1"
strum = { version = "0.25.0", features = ["derive"] }
downcast-rs = "1.2.0"

4
core/src/autodoc/schema.rs
View file

@ -3,7 +3,7 @@
// Crate Uses
use crate::schema::ir::diff::Differ;
use crate::schema::ir::frozen::unit::FrozenUnit;
use crate::schema::ir::compiler::interpreted::primitive::KindValue;
use crate::schema::ir::compiler::interpreted::kind_search::KindValue;
// External Uses
@ -61,7 +61,7 @@ impl Differ for Document {
if left_value_display != right_value_display {
self.minor_changes.push(
format!(
"Constant '{}' default value changed from '{}' to '{}'", name,
"Constant '{}' default value changed from '{:?}' to '{:?}'", name,
left_value_display, right_value_display
)
)

3
core/src/codegen/lua/lib.lua Normal file
View file

@ -0,0 +1,3 @@
-- https://andrejs-cainikovs.blogspot.com/2009/05/lua-constants.html
-- http://lua-users.org/wiki/ReadOnlyTables

52
core/src/codegen/luau/luau.rs Normal file
View file

@ -0,0 +1,52 @@
// Standard Uses
// Crate Uses
use crate::schema::ir::frozen::unit::FrozenUnit;
// External Uses
pub(crate) fn frozen_to_code(units: &Vec<FrozenUnit>) -> String {
let mut code = String::new();
let mut code = "// Generated code with Comline compiler and code generator\n\n"
.to_owned();
for unit in units { code += &*unit_to_code(&unit); }
code
}
fn unit_to_code(frozen_unit: &FrozenUnit) -> String {
let mut code = String::new();
use FrozenUnit::*;
match frozen_unit {
Namespace(_) => {}
Import(_) => {}
Constant { docstring, name, kind_value } => {
let (kind_name, kind_value) = kind_value.name_and_value();
code += &*format!("const {name}: {}", kind_name);
if let Some(value) = kind_value {
code += &*format!(" = {value}");
}
code += ";\n";
}
Property { .. } => {}
Parameter { .. } => {}
ExpressionBlock { .. } => {}
Enum { .. } => {}
EnumVariant(_) => {}
Settings { .. } => {}
Struct { .. } => {}
Protocol { .. } => {}
Function { .. } => {}
Error { .. } => {}
Validator { .. } => {}
_ => panic!("Reached forbidden or unimplemented node")
}
code
}

21
core/src/codegen/luau/mod.rs Normal file
View file

@ -0,0 +1,21 @@
// https://luau-lang.org/
// Relative Modules
pub mod luau;
// Standard Uses
use std::collections::HashMap;
// Crate Uses
use crate::codegen::VersionGenerators;
// External Uses
use once_cell::sync::Lazy;
pub(crate) static GENERATORS: VersionGenerators = Lazy::new(|| {
HashMap::from([
("Luau", luau::frozen_to_code as _)
])
});

25
core/src/codegen/mod.rs
View file

@ -1,5 +1,7 @@
// Relative Modules
pub mod rust;
pub(crate) mod rust;
pub(crate) mod luau;
pub(crate) mod python;
// Standard Uses
use std::collections::HashMap;
@ -11,18 +13,25 @@ use crate::schema::ir::frozen::unit::FrozenUnit;
use once_cell::sync::Lazy;
pub type VersionGenerators = Lazy<HashMap<&'static str, GeneratorFn>>;
pub type GeneratorFn = fn(&Vec<FrozenUnit>) -> String;
pub type Generator = (GeneratorFn, &'static str);
static GENERATORS: Lazy<HashMap<&str, GeneratorFn>> = Lazy::new(|| {
static LANG_GENERATORS: Lazy<HashMap<&str, (&VersionGenerators, &str)>> = Lazy::new(|| {
HashMap::from([
("rust", rust::frozen_unit_to_code as _),
("rust", (&rust::GENERATORS, "rs")),
("luau", (&luau::GENERATORS, "luau")),
("python", (&python::GENERATORS, "py"))
])
});
pub fn find_generator(name: &str) -> Option<&GeneratorFn> {
if !GENERATORS.contains_key(name) {
return None
}
pub fn find_generator(name: &str, version: &str) -> Option<(&'static GeneratorFn, &'static str)> {
if let Some((lang_generator, extension)) = LANG_GENERATORS.get(name) {
if let Some(version_generator) = lang_generator.get(version) {
return Some((version_generator, extension))
}
};
GENERATORS.get(name)
None
}

151
core/src/codegen/python/_3_11_0.rs Normal file
View file

@ -0,0 +1,151 @@
// Standard Uses
// Crate Uses
use crate::schema::ir::frozen::unit::{FrozenArgument, FrozenUnit};
use crate::schema::ir::compiler::interpreted::kind_search::KindValue;
// External Uses
use eyre::anyhow;
#[allow(unused)]
pub fn frozen_to_code(units: &Vec<FrozenUnit>) -> String {
let mut code = "\
# Generated code with Comline compiler and code generator\n\n"
.to_owned();
code += "\
import typing\n\
import ctypes\n\
\n\n\
";
for unit in units { code += &*unit_to_code(&unit); }
code
}
#[allow(unused)]
fn unit_to_code(frozen_unit: &FrozenUnit) -> String {
let mut code = String::new();
use FrozenUnit::*;
match frozen_unit {
Namespace(_) => {}
Import(_) => {}
Constant { docstring, name, kind_value } => {
let (kind_name, default_value) = kind_value.name_and_value();
let Ok(kind_py) = from_frozen_kind_to_python_kind(kind_value) else {
panic!("No appropriate kind was found for '{kind_name}'")
};
// Name and kind
code += &*format!("{name}: typing.Final[{kind_py}]");
// Value
if let Some(value) = default_value {
code += &*format!(" = {value}");
}
code += "\n\n";
}
Property { .. } => {}
Parameter { .. } => {}
ExpressionBlock { .. } => {}
Enum { .. } => {}
EnumVariant(_) => {}
Settings { .. } => {}
Struct { .. } => {}
Protocol {
docstring, parameters,
name, functions
} => {
// Async
// TODO: Can we signify assyncness in python protocols, or if its that important, ABCs?
// Associated methods already can be marked "async"
// Class Start
code += &*format!("class {name}(typing.Protocol):\n");
// Functions
for function in functions {
code += &*unit_to_code(function);
}
// Class End
code += "\n";
}
Function {
docstring, name, synchronous,
arguments, returns,
throws
} => {
// Async definition
if !synchronous { code += "async "; }
// Function Start
code += &*format!("\tdef {name}(");
// Arguments
code += "self";
let mut idx = 0;
while idx != arguments.len() {
let FrozenArgument { name, kind }
= arguments.get(idx).unwrap();
let (kind_name, kind_value) = kind.name_and_value();
code += &*format!("{}: {:?}", name, kind_name);
if idx != arguments.len() { code += ", " }
idx += 1;
}
// Arguments End
code += "):\n\t\t...\n\n";
// Returns
// code += format!("-> {}", return)
// Function End
}
Error { .. } => {}
Validator { .. } => {}
_ => panic!("Reached forbidden or unimplemented node")
}
code
}
fn from_frozen_kind_to_python_kind(kind_value: &KindValue) -> eyre::Result<String> {
let kind = match kind_value {
KindValue::Primitive(primitive) => {
let name = primitive.name();
from_frozen_primitive_to_ctypes(name)
.ok_or_else(|| anyhow!("No primitive equivalent found for {name}"))?
}
KindValue::EnumVariant(_, _) => {
todo!()
}
KindValue::Union(_) => {
todo!()
}
KindValue::Namespaced(_, _) => {
todo!()
}
};
Ok(kind)
}
fn from_frozen_primitive_to_ctypes(primitive: &str) -> Option<String> {
let kind = match primitive {
"u8" => "c_uint8",
"u16" => "c_uint16",
_ => { return None }
};
Some(format!("ctypes.{kind}"))
}

19
core/src/codegen/python/mod.rs Normal file
View file

@ -0,0 +1,19 @@
// Relative Modules
pub(crate) mod _3_11_0;
// Standard Uses
use std::collections::HashMap;
// Crate Uses
use crate::codegen::VersionGenerators;
// External Uses
use once_cell::sync::Lazy;
pub(crate) static GENERATORS: VersionGenerators = Lazy::new(|| {
HashMap::from([
("3.11.0", _3_11_0::frozen_to_code as _)
])
});

102
core/src/codegen/rust.rs
View file

@ -1,102 +0,0 @@
// Standard Uses
// Crate Uses
use crate::schema::ir::frozen::unit::FrozenUnit;
// External Uses
#[allow(unused)]
pub fn frozen_unit_to_code(units: &Vec<FrozenUnit>) -> String {
"".to_owned()
}
/*
fn unit_to_code(frozen_unit: FrozenUnit) -> String {
let mut code = String::new();
use FrozenUnit::*;
match frozen_unit {
Tag(_) => {}
Namespace(_) => {}
Import(_) => {}
Constant { .. } => {}
Property { .. } => {}
Parameter { .. } => {}
ExpressionBlock { .. } => {}
Enum { .. } => {}
EnumVariant(_) => {}
Settings { .. } => {}
Struct { .. } => {}
Protocol { .. } => {}
Function { .. } => {}
Error { .. } => {}
Validator { .. } => {}
_ => panic!("Reached forbidden or unimplemented node")
}
code
}
fn protocol_to_code(unit: FrozenUnit) -> String {
let FrozenUnit::Protocol {
docstring, parameters, name, functions
} = unit else { panic!() };
let mut code = String::new();
// Trait Start
// TODO: Maybe only include async_trait if at least one of the functions need it
code.push_str("#[async_trait]");
code.push_str(&*format!("pub trait {} {{", name));
// Functions
for function in functions {
let FrozenUnit::Function {
docstring, name, synchronous, direction,
arguments, returns, throws
} = function else { panic!() };
let mut fn_code = String::new();
// Async definition (with async_trait)
if !synchronous {
fn_code.push_str("async ");
}
// Fn
fn_code.push_str(&*format!("fn {} (", name));
// Arguments
let mut idx = 0;
while idx != arguments.len() {
let FrozenUnit::Parameter {
name, default_value
} = arguments.get(idx).unwrap();
if argument.id.is_none() {
fn_code.push_str(&*format!("arg{}: {:?}", idx, argument.type_));
if idx != arguments.len() { fn_code.push_str(", ") }
} else {
fn_code.push_str(
&*format!("{}: {:?}", argument.id.clone().unwrap(), argument.type_)
);
if idx != arguments.len() { fn_code.push_str(", ") }
}
idx += 1;
}
// Returns
code.push_str(&*fn_code)
}
// Trait End
code.push_str("}}");
code.to_owned()
}
*/

169
core/src/codegen/rust/_1_7_0.rs Normal file
View file

@ -0,0 +1,169 @@
// Standard Uses
// Crate Uses
use crate::schema::ir::frozen::unit::{FrozenArgument, FrozenUnit};
// External Uses
#[allow(unused)]
pub fn frozen_to_code(units: &Vec<FrozenUnit>) -> String {
let mut code = "// Generated code with Comline compiler and code generator\n\n"
.to_owned();
for unit in units { code += &*unit_to_code(&unit); }
code
}
#[allow(unused)]
fn unit_to_code(frozen_unit: &FrozenUnit) -> String {
let mut code = String::new();
use FrozenUnit::*;
match frozen_unit {
Namespace(_) => {}
Import(_) => {}
Constant { docstring, name, kind_value } => {
let (kind_name, kind_value) = kind_value.name_and_value();
code += &*format!("pub const {name}: {}", kind_name);
if let Some(value) = kind_value {
code += &*format!(" = {value}");
}
code += ";\n\n";
}
Property { .. } => {}
Parameter { .. } => {}
ExpressionBlock { .. } => {}
Enum { .. } => {}
EnumVariant(_) => {}
Settings { .. } => {}
Struct { .. } => {}
Protocol {
docstring, parameters,
name, functions
} => {
// Async
// TODO: Only include async_trait if at least one of the functions needs it
// code += "#[async_trait]\n";
// Trait Start
code += &*format!("pub trait {} {{\n", name);
// Functions
for function in functions {
code += &*unit_to_code(function);
}
// Trait End
code += "\n}\n\n";
}
Function {
docstring, name, synchronous,
arguments, returns,
throws
} => {
code += "\t";
// Async definition (with async_trait)
if !synchronous { code += "async "; }
// Function Start
code += &*format!("fn {} (", name);
code += "&self";
// Arguments
let mut idx = 0;
while idx != arguments.len() {
let FrozenArgument { name, kind }
= arguments.get(idx).unwrap();
let (kind_name, kind_value) = kind.name_and_value();
code += &*format!("{}: {:?}", name, kind_name);
if idx != arguments.len() { code += ", " }
idx += 1;
}
// Arguments End
code += ")";
// Returns
// code += format!("-> {}", return)
// Function End
code += ";\n";
}
Error { .. } => {}
Validator { .. } => {}
_ => panic!("Reached forbidden or unimplemented node")
}
code
}
/*
fn protocol_to_code(unit: FrozenUnit) -> String {
let FrozenUnit::Protocol {
docstring, parameters, name, functions
} = unit else { panic!() };
let mut code = String::new();
// Trait Start
// TODO: Maybe only include async_trait if at least one of the functions need it
code.push_str("#[async_trait]");
code.push_str(&*format!("pub trait {} {{", name));
// Functions
for function in functions {
let FrozenUnit::Function {
docstring, name, synchronous, direction,
arguments, returns, throws
} = function else { panic!() };
let mut fn_code = String::new();
// Async definition (with async_trait)
if !synchronous {
fn_code.push_str("async ");
}
// Fn
fn_code.push_str(&*format!("fn {} (", name));
// Arguments
let mut idx = 0;
while idx != arguments.len() {
let FrozenUnit::Parameter {
name, default_value
} = arguments.get(idx).unwrap();
if argument.id.is_none() {
fn_code.push_str(&*format!("arg{}: {:?}", idx, argument.type_));
if idx != arguments.len() { fn_code.push_str(", ") }
} else {
fn_code.push_str(
&*format!("{}: {:?}", argument.id.clone().unwrap(), argument.type_)
);
if idx != arguments.len() { fn_code.push_str(", ") }
}
idx += 1;
}
// Returns
code.push_str(&*fn_code)
}
// Trait End
code.push_str("}}");
code.to_owned()
}
*/

19
core/src/codegen/rust/mod.rs Normal file
View file

@ -0,0 +1,19 @@
// Relative Modules
pub(crate) mod _1_7_0;
// Standard Uses
use std::collections::HashMap;
// Crate Uses
use crate::codegen::VersionGenerators;
// External Uses
use once_cell::sync::Lazy;
pub(crate) static GENERATORS: VersionGenerators = Lazy::new(|| {
HashMap::from([
("1.70.0", _1_7_0::frozen_to_code as _)
])
});

4
core/src/lib.rs
View file

@ -1,8 +1,8 @@
#![deny(rust_2018_idioms)]
// Extern
extern crate pest;
#[macro_use]
extern crate pest_derive;
extern crate serde;
#[macro_use]
extern crate serde_derive;
extern crate rmp_serde as rmps;

43
core/src/project/build/mod.rs
View file

@ -1,10 +1,10 @@
use std::cell::RefCell;
// Standard Uses
use std::path::Path;
use std::collections::HashMap;
use std::fs::File;
use std::io::Write;
use std::rc::Rc;
use std::cell::RefCell;
// Crate Uses
use crate::codegen;
@ -54,7 +54,9 @@ pub fn build(path: &Path) -> Result<()> {
let unit = idl::parser_new::from_path(concrete_path)?;
let context = ir::context::SchemaContext::with_project_and_main(unit);
let context = ir::context::SchemaContext::with_project_and_main(
unit, concrete_path.file_stem().unwrap().to_str().unwrap().to_owned()
);
compiled_project.add_schema_context(
Rc::new(RefCell::new(context))
@ -63,13 +65,14 @@ pub fn build(path: &Path) -> Result<()> {
compiler::interpret::interpret_context(&mut compiled_project)?;
generate_code_for_targets(&mut compiled_project, &frozen)?;
generate_code_for_targets(&mut compiled_project, &frozen, path)?;
Ok(())
}
pub fn generate_code_for_targets<'a>(
compiled_project: &mut ProjectContext<'a>, frozen_units: &'a Vec<FrozenUnit>
compiled_project: &'a mut ProjectContext<'a>, frozen_units: &'a Vec<FrozenUnit>,
base_path: &Path
) -> Result<()> {
for item in frozen_units.iter() {
match item {
@ -85,18 +88,20 @@ pub fn generate_code_for_targets<'a>(
};
let path = resolve_path_query(&details.generation_path, args).unwrap();
let path = Path::new(&path);
let path = base_path.join(path);
let generator = codegen::find_generator(name);
if generator.is_none() {
let Some((gen_fn, extension)) =
codegen::find_generator(name, version) else
{
panic!(
"No generator found for language named {} with version {}",
"No generator found for language named '{}' with version '{}'",
name, version
)
}
};
generate_code_for_context(&compiled_project, generator, &path)?;
generate_code_for_context(
&compiled_project, gen_fn, extension, &path
)?;
},
_ => {}
}
@ -125,19 +130,23 @@ pub fn resolve_path_query(query: &Option<String>, args: Args) -> Result<String,
}
#[allow(unused)]
pub fn generate_code_for_context(
context: &ProjectContext, generator: Option<&GeneratorFn>,
pub fn generate_code_for_context<'a>(
context: &ProjectContext<'a>,
generator: &GeneratorFn, extension: &str,
target_path: &Path
) -> Result<()> {
std::fs::create_dir_all(target_path)?;
for schema_context in context.schema_contexts.iter() {
let schema_ctx = schema_context.borrow();
let frozen_schema = schema_ctx.frozen_schema.as_ref().unwrap();
let file_path = target_path.join(
format!("{}.{}", &schema_ctx.name, extension)
);
let mut code = "Generated code with Comline compiler".to_owned();
let code = &*generator(frozen_schema);
code += &*generator.unwrap()(frozen_schema);
std::fs::write(target_path, code).unwrap();
std::fs::write(file_path, code).unwrap();
}
Ok(())

6
core/src/project/idl/parser_new.rs
View file

@ -49,7 +49,7 @@ pub fn parse_source(source: String, name: String) -> Result<SourcedWhole> {
Ok((codemap, units))
}
pub fn parse_inner(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
pub fn parse_inner(pair: Pair<'_, Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
match pair.as_rule() {
Rule::congregation => {
let span = pair.as_span();
@ -96,7 +96,7 @@ pub fn parse_inner(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit>
#[allow(unused)]
fn parse_assignment(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<AssignmentUnit> {
fn parse_assignment(pair: Pair<'_, Rule>, file: &Arc<FileMap>) -> Result<AssignmentUnit> {
let unit = match pair.as_rule() {
Rule::number => {
Ok(AssignmentUnit::Number(pair.as_str().parse().unwrap()))
@ -156,7 +156,7 @@ fn parse_assignment(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<AssignmentU
}
fn parse_list_item(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<ListItem> {
fn parse_list_item(pair: Pair<'_, Rule>, file: &Arc<FileMap>) -> Result<ListItem> {
let span = pair.as_span();
let item_span = file.insert_span(span.start(), span.end());

23
core/src/project/ir/compiler/interpret.rs
View file

@ -1,32 +1,29 @@
// Standard Uses
use std::rc::Rc;
// Crate Uses
use crate::project::ir::context::ProjectContext;
use crate::schema::ir::compiler::interpreter::meta_stage;
use crate::schema::ir::compiler::interpreter::{meta_stage, object_stage};
// External Uses
use eyre::{anyhow, Result};
pub fn interpret_context<'a>(
// project_context: &'a RefCell<ProjectContext<'a>>,
project_context: &'a ProjectContext<'a>,
) -> Result<()> {
let len = project_context.schema_contexts.len();
for i in 0..len {
pub fn interpret_context(project_context: &ProjectContext<'_>) -> Result<()> {
for schema_context in project_context.schema_contexts.iter() {
meta_stage::compile_schema_metadata(
&project_context.schema_contexts[i],
Rc::clone(&schema_context),
project_context
).map_err(|e| anyhow!("{}", e))?;
}
/*
for schema_context in project_context.schema_contexts.iter() {
interpreter::interpret_context(schema_context, project_context)
.map_err(|e| anyhow!("{}", e))?;
object_stage::compile_schema(
Rc::clone(&schema_context),
project_context
).map_err(|e| anyhow!("{}", e))?;
}
*/
Ok(())
}

7
core/src/project/ir/compiler/report.rs
View file

@ -11,16 +11,13 @@ use snafu::Snafu;
#[derive(Debug, Snafu)]
#[snafu(visibility(pub(crate)))]
pub enum CompileError {
// #[strum(props(Id="2"))]
#[snafu(display("Found namespace '{target}' when its already declared in '{origin}'"))]
Namespace { origin: String, target: String },
Namespace { origin: String, target: String } = 0,
// #[strum(props(Id="2"))]
#[snafu(display("Spec version was not assigned'"))]
// SpecVersionNotTold { source: Box<dyn std::error::Error + Send + Sync> }
SpecVersionNotTold { source: io::Error },
// #[strum(props(Id="2"))]
#[snafu(display("Schema paths list is empty, at least one schema is required'"))]
// SpecVersionNotTold { source: Box<dyn std::error::Error + Send + Sync> }
SchemaPathsEmpty,
@ -36,4 +33,4 @@ impl From<CompileError> for Error {
}
*/
pub type CompileResult<T, E = CompileError> = std::result::Result<T, E>;
pub type CompileResult<T, E = CompileError> = Result<T, E>;

25
core/src/project/ir/context.rs
View file

@ -50,7 +50,7 @@ impl<'a> ProjectContext<'a> {
)
}
pub(crate) fn add_relative_project_context(mut self, context: Rc<ProjectContext>) {
pub(crate) fn add_relative_project_context(mut self, context: Rc<ProjectContext<'a>>) {
todo!()
}
@ -63,7 +63,7 @@ impl<'a> ProjectContext<'a> {
}
pub(crate) fn find_schema_by_import(&self, import: &str)
-> Option<&'a Rc<RefCell<SchemaContext>>>
-> Option<&Rc<RefCell<SchemaContext<'a>>>>
{
for schema_context in self.schema_contexts.iter() {
let units = &schema_context.borrow().schema.1;
@ -79,6 +79,23 @@ impl<'a> ProjectContext<'a> {
None
}
/*
pub(crate) fn find_schema_by_import(&self, import: &str)
-> Option<&Rc<RefCell<SchemaContext<'a>>>>
{
for schema_context in self.schema_contexts.iter() {
let schema_ctx = schema_context.borrow();
let state = schema_ctx.compile_state.borrow();
if let Some(state) = &state.namespace {
return Some(schema_context)
}
}
None
}
*/
/*
pub(crate) fn find_whole_unit_by_import(&self, import: &str) -> Option<&WholeUnit> {
if self.include_stdlib {
@ -97,7 +114,9 @@ impl<'a> ProjectContext<'a> {
}
*/
pub(crate) fn find_relative_project_context(&self, import: &str) -> Option<&ProjectContext> {
pub(crate) fn find_relative_project_context(&self, import: &str)
-> Option<&ProjectContext<'a>>
{
todo!()
}

4
core/src/project/ir/diff/mod.rs
View file

@ -24,8 +24,8 @@ pub trait Differ: Downcast + Debug {
// fn on_assignment_changed(&self, old: AssignmentUnit, new: AssignmentUnit);
#[allow(unused)]
fn differ(
&self, previous: &Vec<FrozenUnit>, next: &FrozenWhole,
fn differ<'a>(
&self, previous: &Vec<FrozenUnit>, next: &FrozenWhole<'a>,
document_gen: bool, auto_version: bool
) {
// differ(previous, next, document_gen, auto_version)

2
core/src/project/ir/frozen/loader.rs
View file

@ -9,7 +9,7 @@ use eyre::Result;
#[allow(unused)]
pub fn from_frozen_origin(path: &Path) -> Option<FrozenWhole> {
pub fn from_frozen_origin(path: &Path) -> Option<FrozenWhole<'_>> {
// let context = from_frozen_objects(&project_path);
todo!()

2
core/src/project/ir/frozen/mod.rs
View file

@ -47,7 +47,7 @@ pub struct PublishTarget {
}
pub fn schema_paths(units: &Vec<FrozenUnit>)
-> FilterMap<Iter<FrozenUnit>, fn(&FrozenUnit) -> Option<&str>>
-> FilterMap<Iter<'_, FrozenUnit>, fn(&FrozenUnit) -> Option<&str>>
{
units.iter().filter_map(|unit| {
match unit {

19
core/src/project/ir/interpreter/freezing.rs
View file

@ -2,18 +2,17 @@
// Crate Uses
use crate::project::idl::ast::{AssignmentUnit, ASTUnit, DictKeyValue, ListItem};
use crate::project::ir::compiler::report::CompileError;
use crate::project::ir::context::ProjectContext;
use crate::project::ir::frozen::{FrozenUnit, FrozenWhole, LanguageDetails, PublishTarget};
use crate::report::ReportDetails;
use crate::utils::codemap::Span;
// External Uses
#[allow(unused)]
pub fn interpret_node_into_frozen(context: &ProjectContext, node: &ASTUnit)
-> Result<Vec<FrozenUnit>, ReportDetails<CompileError>>
pub fn interpret_node_into_frozen<'a>(
context: &ProjectContext<'a>, node: &ASTUnit
) -> Result<Vec<FrozenUnit>, Box<dyn snafu::Error>>
{
// use crate::project::idl::ast::ASTUnit::*;
match node {
@ -27,9 +26,9 @@ pub fn interpret_node_into_frozen(context: &ProjectContext, node: &ASTUnit)
}
}
pub fn interpret_assignment(
context: &ProjectContext, name: &(Span, String), node: &(Span, AssignmentUnit)
) -> Result<Vec<FrozenUnit>, ReportDetails<CompileError>> {
pub fn interpret_assignment<'a>(
context: &ProjectContext<'a>, name: &(Span, String), node: &(Span, AssignmentUnit)
) -> Result<Vec<FrozenUnit>, Box<dyn snafu::Error>> {
let result = match &*name.1 {
"specification_version" => {
let AssignmentUnit::Number(version) = &node.1 else {
@ -84,7 +83,7 @@ pub fn interpret_assignment(
}
fn interpret_assignment_code_generation(items: &Vec<DictKeyValue>)
-> Result<Vec<FrozenUnit>, ReportDetails<CompileError>>
-> Result<Vec<FrozenUnit>, Box<dyn snafu::Error>>
{
let mut languages = vec![];
@ -144,7 +143,7 @@ fn interpret_assignment_code_generation(items: &Vec<DictKeyValue>)
}
fn interpret_assigment_publish_targets(items: &Vec<DictKeyValue>)
-> Result<Vec<FrozenUnit>, ReportDetails<CompileError>>
-> Result<Vec<FrozenUnit>, Box<dyn snafu::Error>>
{
let mut targets = vec![];
@ -204,7 +203,7 @@ fn interpret_assigment_publish_targets(items: &Vec<DictKeyValue>)
#[allow(unused)]
pub fn into_frozen_whole<'a>(
context: &'a ProjectContext<'a>, interpreted: Vec<FrozenUnit>
) -> Result<FrozenWhole, ReportDetails<CompileError>>
) -> Result<FrozenWhole<'a>, Box<dyn snafu::Error>>
{
todo!()
// Ok((Rc::from(context), interpreted))

6
core/src/project/ir/interpreter/interpret.rs
View file

@ -3,16 +3,14 @@
// Crate Uses
use crate::project::ir::context::ProjectContext;
use crate::project::ir::frozen::FrozenUnit;
use crate::project::ir::compiler::report::CompileError;
use crate::project::ir::interpreter::freezing;
use crate::report::ReportDetails;
// External Uses
#[allow(unused)]
pub fn interpret_context<'a>(mut context: &ProjectContext)
-> Result<Vec<FrozenUnit>, ReportDetails<CompileError>>
pub fn interpret_context<'a>(mut context: &ProjectContext<'a>)
-> Result<Vec<FrozenUnit>, Box<dyn snafu::Error>>
{
let mut interpreted = vec![];

1
core/src/project/ir/interpreter/mod.rs
View file

@ -36,7 +36,6 @@ impl<'a> Compile for Interpreter<'a> {
let frozen = interpret::interpret_context(&context)
.map_err(|e| anyhow!("{:?}", e))?;
// Ok((RefCell::new(context), frozen))
Ok((context, frozen))
}

10
core/src/project/ir/interpreter/report.rs
View file

@ -1,20 +1,15 @@
// Standard Uses
// Crate Uses
use crate::schema::ir::compiler::report::CompileWarning;
use crate::project::idl::ast::AssignmentUnit;
use crate::project::ir::compiler::report::CompileResult;
use crate::project::ir::frozen::Dependency;
use crate::report::ReportDetails;
// External Uses
/*
#[allow(unused)]
pub fn report_errors(
spec_version: Option<u32>, schema_paths: Option<Vec<String>>,
dependencies: Option<Vec<Dependency>>, assignments: Vec<AssignmentUnit>
) -> CompileResult<()> {
) -> Result<(), dyn snafu::Error> {
// let mut errors = vec![];
// let spec_version = spec_version.context(report::SpecVersionNotToldSnafu);
@ -48,3 +43,4 @@ pub fn report_warnings(
warnings
}
*/

34
core/src/report.rs
View file

@ -1,32 +1,35 @@
// Standard Uses
use std::marker::PhantomData;
use std::cell::Ref;
use std::ops::Range;
// Local Uses
// Crate Uses
use crate::schema::ir::context::SchemaContext;
use crate::schema::ir::compiler::report::CompileError;
use crate::utils::codemap::Span;
// External Uses
use ariadne::Color;
#[derive(Debug)]
pub struct ReportDetails<T> {
// pub id: u16,
// pub message: String,
pub(crate) phantom: PhantomData<T>, // pub kind: T,
pub span: Option<Span>
pub struct ReportDetails {
pub line: Range<usize>,
pub pos: Range<usize>
}
#[allow(unused)]
impl<T> ReportDetails<T> {
fn code(&self) -> u8 {
0
impl ReportDetails {
pub(crate) fn fetch(
schema_context: &Ref<'_, SchemaContext<'_>>, span: &Span
) -> Option<Self> {
let pos = schema_context.schema.0.files().first()
.unwrap().range_of(*span).unwrap();
Some(Self { line: Default::default(), pos })
}
}
/*
#[allow(unused)]
pub fn report_errors(context: SchemaContext, errors: Vec<ReportDetails<CompileError>>) {
pub fn report_errors<'a>(context: SchemaContext<'_>, errors: Vec<ReportDetails<CompileError>>) {
let out = Color::Fixed(81);
/*
@ -47,8 +50,9 @@ pub fn report_errors(context: SchemaContext, errors: Vec<ReportDetails<CompileEr
#[allow(unused)]
pub fn report_warnings(context: SchemaContext, warnings: Vec<ReportDetails<CompileError>>) {
pub fn report_warnings(context: SchemaContext<'_>, warnings: Vec<ReportDetails<CompileError>>) {
todo!()
}
*/

5
core/src/schema/idl/ast/unit.rs
View file

@ -79,7 +79,9 @@ pub enum ASTUnit {
throws: Vec<(Span, String)>
},
Argument {
name: Option<(Span, String)>, // TODO: Having optional names might not be a good thing
// TODO: Having optional names might not be a good thing, think about it
// name: Option<(Span, String)>,
name: (Span, String),
kind: (Span, String)
},
Error {
@ -107,6 +109,7 @@ pub enum ASTUnit {
}
#[allow(unused)]
pub(crate) fn namespace(units: &Vec<SpannedUnit>) -> &String {
let mut namespace: Option<&String> = None;

9
core/src/schema/idl/idl.pest
View file

@ -134,7 +134,7 @@ protocol = {
~ "{" ~ WS? ~ function* ~ WS? ~ "}"
}
function = {
WS? ~ property*
WS? ~ docstring? ~ property*
~ (index ~ WS? ~ "#" ~ WS?)?
~ (asynchronous ~ WS?)?
~ (direction ~ WS?)?
@ -143,6 +143,7 @@ function = {
~ (WS? ~ "->" ~ WS? ~ returns+)?
// ~ (WS? ~ ":" ~ WS? ~ parameter+)?
~ (WS? ~ "!" ~ WS? ~ throws)?
~ ";"
}
direction = { "client" | "server" }
@ -153,15 +154,15 @@ argument = {
~ WS?
}
returns = { ","? ~ WS? ~ (kind) ~ WS? }
parameter = {
WS? ~ id ~ WS? ~ "=" ~ WS? ~ value ~ WS?
}
throws = {
function_call
}
// Common Rules
parameter = {
WS? ~ id ~ WS? ~ "=" ~ WS? ~ value ~ WS?
}
property = {
WS? ~ "@"
~ WS? ~ property_domain

10
core/src/schema/idl/parser.rs
View file

@ -175,7 +175,7 @@ pub fn parse_inner(pairs: Pair<Rule>) -> Result<ASTUnit> {
}
*/
pub fn to_docstring(pair: Pair<Rule>, file: &Arc<FileMap>) -> SpannedUnit {
pub fn to_docstring(pair: Pair<'_, Rule>, file: &Arc<FileMap>) -> SpannedUnit {
let pair = pair.into_inner().next().unwrap();
match pair.as_rule() {
@ -238,7 +238,7 @@ pub fn to_parameters(mut pairs: Pairs<Rule>) -> Vec<Parameter> {
}
*/
pub fn to_value_other(pair: Pair<Rule>) -> Option<String> {
pub fn to_value_other(pair: Pair<'_, Rule>) -> Option<String> {
let inner = pair.into_inner().next().unwrap();
match inner.as_rule() {
@ -252,7 +252,7 @@ pub fn to_value_other(pair: Pair<Rule>) -> Option<String> {
}
#[allow(unused)]
pub fn to_field(pair: Pair<Rule>, file: &Arc<FileMap>) -> ASTUnit {
pub fn to_field(pair: Pair<'_, Rule>, file: &Arc<FileMap>) -> ASTUnit {
let pairs = pair.into_inner();
let mut docstring = vec![];
@ -298,7 +298,7 @@ pub fn to_property(pair: Pair<Rule>, file: &Arc<FileMap>) -> ASTUnit {
*/
#[allow(unused)]
fn to_function(pair: Pair<Rule>) -> ASTUnit {
fn to_function(pair: Pair<'_, Rule>) -> ASTUnit {
let inner = pair.into_inner();
let mut synchronous = true;
@ -370,7 +370,7 @@ fn to_argument(pairs: Pairs<Rule>) -> Argument {
}
*/
pub fn to_expression_block(pair: Pair<Rule>) -> ASTUnit {
pub fn to_expression_block(pair: Pair<'_, Rule>) -> ASTUnit {
let inner = pair.into_inner().next().unwrap();
// let mut expression = vec![];

27
core/src/schema/idl/parser_new.rs
View file

@ -1,10 +1,11 @@
// Standard Uses
use std::path::Path;
use std::rc::Rc;
use std::sync::Arc;
// Local Uses
use crate::utils::codemap::{CodeMap, FileMap};
use crate::schema::idl::ast::unit::{ASTUnit, SourcedWhole, SpannedUnit};
use crate::schema::idl::ast::unit::{ASTUnit, SourcedWholeRc, SpannedUnit};
// External Uses
use eyre::{bail, Result};
@ -18,7 +19,7 @@ pub struct SchemaParser;
#[allow(unused)]
pub fn from_path(path: &Path) -> Result<SourcedWhole> {
pub fn from_path(path: &Path) -> Result<SourcedWholeRc> {
if !path.exists() { bail!("Path doesn't exist: {:?}", path) }
let source = std::fs::read_to_string(path).unwrap();
@ -30,7 +31,7 @@ pub fn from_path(path: &Path) -> Result<SourcedWhole> {
sourced_whole
}
pub fn parse_source(source: String, name: String) -> Result<SourcedWhole> {
pub fn parse_source(source: String, name: String) -> Result<SourcedWholeRc> {
let mut codemap = CodeMap::new();
let file = codemap.insert_file(name, source.clone());
@ -39,7 +40,7 @@ pub fn parse_source(source: String, name: String) -> Result<SourcedWhole> {
for pair in pairs {
if let Ok(unit) = parse_inner(pair, &file) {
units.push(unit)
units.push(Rc::new(unit))
}
}
@ -47,7 +48,7 @@ pub fn parse_source(source: String, name: String) -> Result<SourcedWhole> {
}
#[allow(unused)]
pub fn parse_inner(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
pub fn parse_inner(pair: Pair<'_, Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
match pair.as_rule() {
Rule::namespace => {
let span = pair.as_span();
@ -261,7 +262,7 @@ pub fn parse_inner(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit>
}
pub fn to_docstring(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
pub fn to_docstring(pair: Pair<'_, Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
let pair = pair.into_inner().next().unwrap();
match pair.as_rule() {
@ -299,7 +300,7 @@ pub fn to_docstring(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit
#[allow(unused)]
pub fn to_parameter(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
pub fn to_parameter(pair: Pair<'_, Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
let pair_span = pair.as_span();
let unit_span = file.insert_span(pair_span.start(), pair_span.end());
let mut inner = pair.into_inner();
@ -323,7 +324,7 @@ pub fn to_parameter(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit
#[allow(unused)]
pub fn to_field(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
pub fn to_field(pair: Pair<'_, Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
let pair_span = pair.as_span();
let unit_span = file.insert_span(pair_span.start(), pair_span.end());
let mut inner = pair.into_inner();
@ -354,7 +355,7 @@ pub fn to_field(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
}))
}
pub fn to_property(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
pub fn to_property(pair: Pair<'_, Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
let pair_span = pair.as_span();
let unit_span = file.insert_span(pair_span.start(), pair_span.end());
let inner = pair.into_inner().next().unwrap();
@ -380,7 +381,7 @@ pub fn to_property(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit>
#[allow(unused)]
fn to_enum_variant(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
fn to_enum_variant(pair: Pair<'_, Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
let pair_span = pair.as_span();
let unit_span = file.insert_span(pair_span.start(), pair_span.end());
let inner = pair.into_inner();
@ -405,7 +406,7 @@ fn to_enum_variant(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit>
}
#[allow(unused)]
fn to_function(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
fn to_function(pair: Pair<'_, Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
let pair_span = pair.as_span();
let unit_span = file.insert_span(pair_span.start(), pair_span.end());
let inner = pair.into_inner();
@ -436,10 +437,10 @@ fn to_function(pair: Pair<Rule>, file: &Arc<FileMap>) -> Result<SpannedUnit> {
let kind_span = kind_pair.as_span();
arguments.push((unit_span, ASTUnit::Argument {
name: Some((
name: (
file.insert_span(name_span.start(), name_span.end()),
name_pair.as_str().to_owned()
)),
),
kind: (
file.insert_span(kind_span.start(), kind_span.end()),
kind_pair.as_str().to_owned()

296
core/src/schema/ir/compiler/interpreted/interpreter.rs
View file

@ -1,296 +0,0 @@
// Standard Uses
use std::cell::RefMut;
// Local Uses
use crate::schema::idl::ast::unit::{ASTUnit, SpannedUnit};
use crate::schema::ir::context::SchemaContext;
use crate::schema::ir::compiler::interpreted::primitive::KindValue;
use crate::schema::ir::compiler::report::CompileError;
use crate::schema::ir::frozen::unit::FrozenUnit;
use crate::project::ir::context::ProjectContext;
use crate::report::ReportDetails;
// External Uses
#[allow(unused)]
pub fn interpret_context<'a>(
schema_context: &'a mut SchemaContext<'a>,
project_context: &'a RefMut<ProjectContext<'a>>
) -> Result<(), ReportDetails<CompileError>> {
let mut interpreted: Vec<FrozenUnit> = vec![];
for i in 0..schema_context.schema.1.len() {
let spanned_unit = &schema_context.schema.1[i];
use crate::schema::idl::ast::unit::ASTUnit::*;
match &spanned_unit.1 {
Namespace(s, n) => {
let name = n.clone();
let Some(ctx)
= project_context.find_schema_by_import(&n) else
{
return Err(ReportDetails {
// kind: "Namespace".to_string(),
/*
message: format!(
"Namespace {} used in another schema: {} and {},\n \
only one schema per namespace is allowed",
n, context.main.0.filename(), unit_namespace.unwrap().0.filename()
),
start: 0, end: 0,
*/
phantom: Default::default(),
span: None,
})
};
if let Some(name) = &schema_context.compile_state.borrow_mut().namespace {
panic!("Namespace {} was already previously set", name)
} else {
schema_context.compile_state.borrow_mut().namespace = Some(name)
}
}
Docstring {..} => {
todo!()
}
Import(s, i) => {
/*
let Some(ctx)
= project_context.find_schema_by_import(i) else {
panic!("No import")
};
*/
}
// Docstring { .. } => {}
Constant {
docstring, name,
kind, default_value
} => {
/*
let kind_value = primitive::to_kind_value(
schema_context, kind, default_value
);
*/
}
Property { .. } => {}
Parameter { .. } => {}
ExpressionBlock { .. } => {}
Enum { .. } => {}
EnumVariant { .. } => {}
Settings { .. } => {}
Struct { .. } => {}
Protocol { .. } => {}
Function { .. } => {}
Argument { .. } => {}
Error { .. } => {}
Validator { .. } => {}
Field { .. } => {}
}
}
// Ok(context.unwrap().compile_state.to_frozen())
Ok(())
/*
for (unit, span) in &context.config.1 {
use crate::schema::idl::ast::unit::ASTUnit::*;
match unit {
ASTUnit::Namespace(n) => {
let unit_namespace = context.find_whole_unit_by_import(n);
/*
if unit_namespace.is_some() {
return Err(ReportDetails {
kind: "Namespace".to_string(),
message: format!(
"Namespace {} used in another schema: {} and {},\n \
only one schema per namespace is allowed",
n, context.main.0.filename(), unit_namespace.unwrap().0.filename()
),
start: 0, end: 0,
})
}
*/
interpreted.push(FrozenUnit::Namespace(n.clone()));
},
Import(_) => {
let import = interpret_node(&context, unit)?;
interpreted.push(import);
}
Constant { .. } => {
let constant = interpret_node(&context, unit)?;
interpreted.push(constant);
}
Enum { .. } => {
let r#enum = interpret_node(&context, unit)?;
interpreted.push(r#enum);
}
/*
Unit::Settings { .. } => {}
Unit::Struct { .. } => {}
Unit::Protocol { .. } => {}
Unit::Error { .. } => {}
*/
Validator { .. } => {
let validator = interpret_node(&context, unit)?;
interpreted.push(validator);
}
/*
//r => panic!("Left to impl: {:?}", r)
*/
_ => {}
}
}
*/
}
#[allow(unused)]
pub fn interpret_node<'a>(
schema_context: &'a SchemaContext<'a>,
project_context: &'a ProjectContext<'a>,
node: &ASTUnit
)
-> Result<FrozenUnit, ReportDetails<CompileError>>
{
use crate::schema::idl::ast::unit::ASTUnit::*;
match node {
Namespace(_, n) => {
let mut found: Option<&SchemaContext> = None;
/*
for relative_ctx in schema_ctx.borrow().schema_contexts.iter() {
if unit::namespace(&relative_ctx.schema.1) == n {
/*
if found.is_some() {
return Err(ReportDetails {
kind: "namespace".to_string(),
message: format!(
"Found namespace {} when its already declared in {}",
&n, &relative_ctx.main.0.filename()
),
start: 0, end: 0,
})
}
*/
found = Some(relative_ctx)
}
}
*/
}
Import(_, i) => {
let relative_unit = project_context.find_schema_by_import(&i);
/*
if relative_unit.is_none() {
let relative_unit = relative_unit.unwrap();
return Err(ReportDetails {
kind: "import".to_string(),
message: format!("Could not find namespace of {}", relative_unit.0.filename()),
start: 0, end: 0,
})
}
*/
return Ok(FrozenUnit::Import(i.clone()))
},
Constant {
name: (_, name), kind: (_, kind),
default_value, ..
} => {
/*
let kind_value = primitive::to_kind_value(kind, default_value);
return Ok(FrozenUnit::Constant {
docstring: None,
name: name.clone(), kind_value
})
*/
}
Enum { name, variants, .. } => {
let mut frozen_variants: Vec<FrozenUnit> = vec![];
for variant in variants {
pub(crate) fn to_variant(variant: &ASTUnit) -> KindValue {
match variant {
EnumVariant { name, kind } => {
if kind.is_none() {
return KindValue::EnumVariant(
name.1.clone(),None
)
}
return KindValue::EnumVariant(
name.1.clone(), None
)
},
_ => panic!("Should not be here")
}
}
frozen_variants.push(FrozenUnit::EnumVariant(
to_variant(&variant.1)
));
}
return Ok(FrozenUnit::Enum {
docstring: None,
name: name.1.clone(),
variants: frozen_variants
})
}
/*
EnumVariant { .. } => {}
Settings { .. } => {}
Struct { .. } => {}
Protocol { .. } => {}
Function { .. } => {}
Error { .. } => {}
*/
#[allow(unused)]
Validator {
docstring, properties,
name, expression_block
} => {
let properties = to_properties(properties);
let expr_block = Box::new(FrozenUnit::ExpressionBlock { function_calls: vec![] });
return Ok(FrozenUnit::Validator {
docstring: Some("".to_owned()), // TODO: Docstrings should likely be a vector of units
properties: vec![],
name: name.1.clone(),
expression_block: expr_block
})
}
/*
Field { .. } => {}
Parameter { .. } => {}
Property { .. } => {}
ExpressionBlock { .. } => {}
*/
missing => unimplemented!("Missing implementation for node '{:?}'", missing)
}
panic!()
}
#[allow(unused)]
fn to_properties(nodes: &Vec<SpannedUnit>) -> Vec<FrozenUnit> {
let properties = vec![];
for node in nodes {
}
properties
}
pub fn into_frozen_unit() -> FrozenUnit {
todo!()
}

156
core/src/schema/ir/compiler/interpreted/primitive.rs → core/src/schema/ir/compiler/interpreted/kind_search.rs
View file

@ -1,21 +1,28 @@
// Standard Uses
use std::cell::Ref;
// Local Uses
use std::cell::RefCell;
use std::rc::Rc;
// External Uses
use strum_macros::EnumProperty;
use crate::schema::ir::context::SchemaContext;
use crate::schema::ir::compiler::report::CompileError;
use crate::schema::ir::compiler::report;
use crate::project::ir::context::ProjectContext;
use crate::report::ReportDetails;
use crate::utils::codemap::Span;
// External Uses
use strum_macros::EnumProperty;
use snafu::ResultExt;
#[derive(Debug, Eq, PartialEq, Deserialize, Serialize)]
#[derive(EnumProperty)]
#[derive(Debug, Eq, PartialEq)]
#[derive(Deserialize, Serialize, EnumProperty)]
#[repr(u8)]
pub enum Primitive {
#[strum(props(Name="bool", Description="boolean, 1 byte"))]
Boolean(Option<bool>) = 0,
#[strum(props(Name="u8", Description="unsigned 1 byte, 8 bits"))]
U8(Option<u8>) = 0,
U8(Option<u8>),
#[strum(props(Name="u16", Description="unsigned 2 bytes, 16 bits"))]
U16(Option<u16>),
@ -53,6 +60,9 @@ pub enum Primitive {
impl Primitive {
pub fn value_str(&self) -> Option<String> {
match self {
Primitive::Boolean(b) => {
if let Some(b) = b { Some(b.to_string()) } else { None }
}
Primitive::U8(u) => {
if let Some(u) = u { Some(u.to_string()) } else { None }
}
@ -92,6 +102,11 @@ impl Primitive {
}
}
pub fn name(&self) -> &str {
use strum::EnumProperty;
self.get_str("Name").unwrap()
}
pub fn name_description(&self) -> String {
use strum::EnumProperty;
format!("{}({})", self.get_str("Name").unwrap(), self.get_str("Description").unwrap())
@ -113,14 +128,14 @@ pub enum KindValue {
Primitive(Primitive),
EnumVariant(String, Option<Box<KindValue>>),
Union(Vec<KindValue>),
Namespaced(String)
Namespaced(String, Option<Box<KindValue>>)
}
impl KindValue {
pub fn name_and_value(&self) -> (String, String) {
pub fn name_and_value(&self) -> (String, Option<String>) {
match self {
KindValue::Primitive(primitive) => {
return (primitive.name_description(), primitive.value_str().unwrap())
return (primitive.name().to_owned(), Some(primitive.value_str().unwrap()))
}
KindValue::EnumVariant(name, value) => {
let value = value.as_ref().unwrap();
@ -131,37 +146,121 @@ impl KindValue {
todo!()
}
#[allow(unused)]
KindValue::Namespaced(namespace) => {
KindValue::Namespaced(namespace, ..) => {
todo!()
}
}
}
}
pub(crate) fn to_kind_value(
schema_context: &Rc<RefCell<SchemaContext>>,
pub fn resolve_kind_value(
schema_context: &Ref<'_, SchemaContext<'_>>, project_context: &'_ ProjectContext<'_>,
kind: &(Span, String), value: &Option<(Span, String)>
) -> KindValue {
) -> Result<KindValue, Box<dyn snafu::Error>> {
if value.is_none() {
return to_kind_only(kind)
if let Some(kind) = to_kind_only(schema_context, project_context, kind) {
return Ok(kind)
}
}
KindValue::Primitive(
to_primitive(schema_context, kind, value.clone().unwrap().1).unwrap()
)
}
if let Some(kind_value) = to_kind_value(
schema_context, kind, &value.as_ref().unwrap()
) {
return Ok(kind_value)
};
fn to_kind_only(kind: &(Span, String)) -> KindValue {
match kind {
&_ => panic!("Cant")
}
Err(CompileError::TypeNotFound { name: kind.1.clone() })
.context(report::CompileSnafu {
details: ReportDetails::fetch(schema_context, &kind.0).unwrap()
})?
}
#[allow(unused)]
fn to_primitive(
schema_context: &Rc<RefCell<SchemaContext>>,
kind: &(Span, String), value: String
pub(crate) fn to_kind_value(
schema_context: &Ref<'_, SchemaContext<'_>>,
kind: &(Span, String), value: &(Span, String)
) -> Option<KindValue> {
if let Some(primitive) = to_primitive_kind_value(kind, &value.1) {
return Some(KindValue::Primitive(primitive))
}
None
}
#[allow(unused)]
pub(crate) fn to_kind_only(
schema_context: &Ref<'_, SchemaContext<'_>>, project_context: &'_ ProjectContext<'_>,
kind: &(Span, String)
) -> Option<KindValue> {
if let Some(primitive) = to_primitive_kind_only(kind) {
return Some(KindValue::Primitive(primitive))
}
if let Some(namespaced) = to_namespaced_kind_only(schema_context, kind) {
return Some(namespaced)
}
if let Some(union) = to_union_kind_only(schema_context, kind) {
return Some(union)
}
None
}
fn to_namespaced_kind_only(
schema_context: &Ref<'_, SchemaContext<'_>>, kind: &(Span, String)
) -> Option<KindValue> {
let state = schema_context.compile_state.borrow();
for (_, structure) in state.structures.iter() {
if structure.name.1 == kind.1 {
return Some(KindValue::Namespaced(
structure.name.1.clone(), None
))
}
}
for (_, constant) in state.consts.iter() {
if constant.name.1 == kind.1 {
return Some(KindValue::Namespaced(
constant.name.1.clone(), None
))
}
}
None
}
fn to_union_kind_only(
schema_context: &Ref<'_, SchemaContext<'_>>, kind: &(Span, String)
) -> Option<KindValue> {
todo!()
}
fn to_primitive_kind_only(kind: &(Span, String)) -> Option<Primitive> {
use self::Primitive::*;
match &*kind.1 {
"u8" => Some(U8(None)),
"u16" => Some(U16(None)),
"u32" => Some(U32(None)),
"u64" => Some(U64(None)),
"u128" => Some(U128(None)),
"s8" => Some(S8(None)),
"s16" => Some(S16(None)),
"s32" => Some(S32(None)),
"s64" => Some(S64(None)),
"s128" => Some(S128(None)),
"str" => Some(String(None)),
"bool" => Some(Boolean(None)),
_ => { None }
}
}
fn to_primitive_kind_value<'a>(
kind: &(Span, String), value: &str
) -> Option<Primitive> {
use self::Primitive::*;
let kv = match &*kind.1 {
@ -178,6 +277,7 @@ fn to_primitive(
"s128" => S128(Some(value.parse().unwrap())),
"str" => String(Some(value.to_owned())),
"bool" => Boolean(Some(value.parse().unwrap())),
_ => { panic!("Got unknown type '{:#}'", kind.1) }
};

3
core/src/schema/ir/compiler/interpreted/mod.rs
View file

@ -1,6 +1,5 @@
// Relative Modules
pub mod sanitizer;
pub mod serialization;
pub mod primitive;
pub mod interpreter;
pub mod kind_search;

2
core/src/schema/ir/compiler/interpreted/sanitizer.rs
View file

@ -7,6 +7,6 @@ use crate::schema::ir::context::SchemaContext;
#[allow(unused)]
fn sanitize_context_units(context: &SchemaContext) {
fn sanitize_context_units(context: &SchemaContext<'_>) {
todo!()
}

79
core/src/schema/ir/compiler/interpreter/meta_stage.rs
View file

@ -1,20 +1,23 @@
// Standard Uses
use std::cell::RefCell;
use std::rc::Rc;
use crate::project::ir::context::ProjectContext;
use snafu::ResultExt;
// Crate Uses
use crate::report::ReportDetails;
use crate::schema::ir::compiler::report::CompileError;
use crate::schema::ir::context::SchemaContext;
use crate::project::ir::context::ProjectContext;
use crate::schema::ir::compiler::interpreter::semi_frozen;
use crate::schema::ir::compiler::report;
use crate::schema::ir::compiler::report::CompileError;
// External Uses
pub fn compile_schema_metadata<'a>(
schema_context: &Rc<RefCell<SchemaContext>>,
project_context: &'a ProjectContext<'a>
) -> Result<(), ReportDetails<CompileError>> {
schema_context: Rc<RefCell<SchemaContext<'a>>>,
project_context: &ProjectContext<'a>
) -> Result<(), Box<dyn snafu::Error>> {
let schema_ctx = schema_context.borrow();
for i in 0..schema_ctx.schema.1.len() {
@ -22,24 +25,14 @@ pub fn compile_schema_metadata<'a>(
use crate::schema::idl::ast::unit::ASTUnit::*;
match &spanned_unit.1 {
Namespace(_, n) => {
Namespace(span, n) => {
let name = n.clone();
let Some(_) = project_context.find_schema_by_import(&n) else
{
return Err(ReportDetails {
// kind: "Namespace".to_string(),
/*
message: format!(
"Namespace {} used in another schema: {} and {},\n \
only one schema per namespace is allowed",
n, context.main.0.filename(), unit_namespace.unwrap().0.filename()
),
start: 0, end: 0,
*/
phantom: Default::default(),
span: None,
})
let Some(_) = project_context.find_schema_by_import(&n) else {
Err(CompileError::NamespaceCollision {
origin: "aa".to_string(), target: "aaa".to_string()
}).context(report::CompileSnafu {
details: ReportDetails::fetch(&schema_ctx, span).unwrap()
})?
};
let mut compile_state = schema_ctx.compile_state.borrow_mut();
@ -52,23 +45,33 @@ pub fn compile_schema_metadata<'a>(
Docstring {..} => {
todo!()
}
Import(_, _) => {
/*
let Some(ctx)
= project_context.find_schema_by_import(i) else {
panic!("No import")
};
*/
Import(span, import) => {
let spanned = Rc::clone(&spanned_unit);
schema_ctx.compile_state.borrow_mut().imports.entry(spanned).or_insert(
semi_frozen::Import {
namespace: (*span, import.clone()),
// alias: alias.clone
}
);
}
// Docstring { .. } => {}
#[allow(unused)]
Constant { name, ..} => {
/*
let spanned_unit = Rc::clone(&spanned_unit);
schema_ctx.compile_state.borrow_mut().consts
.entry(&spanned_unit).or_insert(
SemiFrozenUnit::Constant { name: name.clone() }
.entry(spanned_unit).or_insert(
semi_frozen::Constant { name: name.clone() }
);
}
Struct { name, .. } => {
let spanned_unit = Rc::clone(&spanned_unit);
schema_ctx.compile_state.borrow_mut().structures
.entry(spanned_unit).or_insert(
semi_frozen::Structure { name: name.clone() }
);
*/
}
Property { .. } => {}
Parameter { .. } => {}
@ -76,8 +79,14 @@ pub fn compile_schema_metadata<'a>(
Enum { .. } => {}
EnumVariant { .. } => {}
Settings { .. } => {}
Struct { .. } => {}
Protocol { .. } => {}
Protocol { name, .. } => {
let spanned_unit = Rc::clone(&spanned_unit);
schema_ctx.compile_state.borrow_mut().protocols
.entry(spanned_unit).or_insert(
semi_frozen::Protocol { name: name.clone() }
);
}
Function { .. } => {}
Argument { .. } => {}
Error { .. } => {}

335
core/src/schema/ir/compiler/interpreter/object_stage.rs
View file

@ -1,18 +1,343 @@
// Standard Uses
use std::rc::Rc;
use std::cell::RefCell;
use std::cell::{Ref, RefCell};
// Crate Uses
use crate::report::ReportDetails;
use crate::schema::ir::compiler::report::CompileError;
use crate::schema::ir::context::SchemaContext;
use crate::schema::idl::ast::unit::{ASTUnit, SpannedUnit};
use crate::schema::ir::compiler::interpreted::kind_search;
use crate::schema::ir::compiler::interpreted::kind_search::{KindValue};
use crate::schema::ir::frozen::unit::{FrozenArgument, FrozenUnit};
use crate::project::ir::context::ProjectContext;
// External Uses
#[allow(unused)]
pub fn compile_schema_metadata(schema_context: &Rc<RefCell<SchemaContext>>
) -> Result<(), ReportDetails<CompileError>>
pub fn compile_schema<'a>(
schema_context: Rc<RefCell<SchemaContext<'a>>>,
project_context: &ProjectContext<'a>
) -> Result<(), Box<dyn snafu::Error>> {
let schema_ctx = schema_context.borrow();
let mut interpreted: Vec<FrozenUnit> = vec![];
for spanned_unit in &schema_ctx.schema.1 {
use crate::schema::idl::ast::unit::ASTUnit::*;
match &spanned_unit.1 {
Namespace(..) => {}
Docstring {..} => {
todo!()
}
Import(s, i) => {
let Some(import_ctx)
= project_context.find_schema_by_import(i) else {
panic!("No schema found by import '{}'", i)
};
}
// Docstring { .. } => {}
Constant {
docstring, name,
kind, default_value
} => {
let state = schema_ctx.compile_state.borrow();
let kind_value = kind_search::resolve_kind_value(
&schema_ctx, project_context, kind, default_value
)?;
interpreted.push(FrozenUnit::Constant {
docstring: None,
name: name.1.clone(),
kind_value,
});
}
Property { .. } => {}
Parameter { .. } => {}
ExpressionBlock { .. } => {}
Enum { .. } => {}
EnumVariant { .. } => {}
Settings { .. } => {}
Struct { .. } => {}
Protocol {
docstring, parameters,
name, functions
} => {
let state = schema_ctx.compile_state.borrow();
let mut params = vec![];
let mut funcs = vec![];
for function in functions {
funcs.push(to_function_frozen(
&schema_ctx, &project_context, function
)?);
}
interpreted.push(FrozenUnit::Protocol {
docstring: "".to_string(),
parameters: params,
name: name.1.clone(),
functions: funcs,
});
}
Function { name, .. } => {
}
Argument { .. } => {}
Error { .. } => {}
Validator { .. } => {}
Field { .. } => {}
}
}
drop(schema_ctx);
let mut schema_ctx = RefCell::borrow_mut(&schema_context);
schema_ctx.frozen_schema = Some(interpreted);
Ok(())
/*
for (unit, span) in &context.config.1 {
use crate::schema::idl::ast::unit::ASTUnit::*;
match unit {
ASTUnit::Namespace(n) => {
let unit_namespace = context.find_whole_unit_by_import(n);
/*
if unit_namespace.is_some() {
return Err(ReportDetails {
kind: "Namespace".to_string(),
message: format!(
"Namespace {} used in another schema: {} and {},\n \
only one schema per namespace is allowed",
n, context.main.0.filename(), unit_namespace.unwrap().0.filename()
),
start: 0, end: 0,
})
}
*/
interpreted.push(FrozenUnit::Namespace(n.clone()));
},
Import(_) => {
let import = interpret_node(&context, unit)?;
interpreted.push(import);
}
Constant { .. } => {
let constant = interpret_node(&context, unit)?;
interpreted.push(constant);
}
Enum { .. } => {
let r#enum = interpret_node(&context, unit)?;
interpreted.push(r#enum);
}
/*
Unit::Settings { .. } => {}
Unit::Struct { .. } => {}
Unit::Protocol { .. } => {}
Unit::Error { .. } => {}
*/
Validator { .. } => {
let validator = interpret_node(&context, unit)?;
interpreted.push(validator);
}
/*
//r => panic!("Left to impl: {:?}", r)
*/
_ => {}
}
}
*/
}
fn to_function_frozen(
schema_ctx: &Ref<'_, SchemaContext<'_>>, project_context: &'_ ProjectContext<'_>,
spanned_unit: &SpannedUnit
) -> Result<FrozenUnit, Box<dyn snafu::Error>> {
#[allow(unused)]
let ASTUnit::Function {
docstring, parameters, name,
asynchronous,
arguments, returns, throws
} = &spanned_unit.1 else { panic!() };
let sync = || { if let Some(_) = asynchronous { false } else { true } };
let mut args = vec![];
let mut rets = vec![];
for (_, unit) in arguments {
let ASTUnit::Argument { name, kind } = unit else { panic!() };
let Some(kind) = kind_search::to_kind_only(
&schema_ctx, project_context, kind
) else { panic!() };
args.push(FrozenArgument {
name: name.1.clone(),
kind
});
}
for ret in returns {
let Some(kind) = kind_search::to_kind_only(
&schema_ctx, project_context, ret
) else { panic!() };
rets.push(kind);
}
Ok(FrozenUnit::Function {
docstring: "".to_string(),
name: name.1.clone(),
synchronous: sync(),
// direction: Box::new(()),
arguments: args,
returns: rets,
throws: vec![],
})
}
#[allow(unused)]
pub fn interpret_node<'a>(
schema_context: &'a SchemaContext<'a>,
project_context: &'a ProjectContext<'a>,
node: &ASTUnit
) -> Result<FrozenUnit, Box<dyn snafu::Error>>
{
use crate::schema::idl::ast::unit::ASTUnit::*;
match node {
Namespace(_, n) => {
let mut found: Option<&SchemaContext<'a>> = None;
/*
for relative_ctx in schema_ctx.borrow().schema_contexts.iter() {
if unit::namespace(&relative_ctx.schema.1) == n {
/*
if found.is_some() {
return Err(ReportDetails {
kind: "namespace".to_string(),
message: format!(
"Found namespace {} when its already declared in {}",
&n, &relative_ctx.main.0.filename()
),
start: 0, end: 0,
})
}
*/
found = Some(relative_ctx)
}
}
*/
}
Import(_, i) => {
let relative_unit = project_context.find_schema_by_import(&i);
/*
if relative_unit.is_none() {
let relative_unit = relative_unit.unwrap();
return Err(ReportDetails {
kind: "import".to_string(),
message: format!("Could not find namespace of {}", relative_unit.0.filename()),
start: 0, end: 0,
})
}
*/
return Ok(FrozenUnit::Import(i.clone()))
},
Constant {
name: (_, name), kind: (_, kind),
default_value, ..
} => {
/*
let kind_value = primitive::to_kind_value(kind, default_value);
return Ok(FrozenUnit::Constant {
docstring: None,
name: name.clone(), kind_value
})
*/
}
Enum { name, variants, .. } => {
let mut frozen_variants: Vec<FrozenUnit> = vec![];
for variant in variants {
pub(crate) fn to_variant(variant: &ASTUnit) -> KindValue {
match variant {
EnumVariant { name, kind } => {
if kind.is_none() {
return KindValue::EnumVariant(
name.1.clone(),None
)
}
return KindValue::EnumVariant(
name.1.clone(), None
)
},
_ => panic!("Should not be here")
}
}
frozen_variants.push(FrozenUnit::EnumVariant(
to_variant(&variant.1)
));
}
return Ok(FrozenUnit::Enum {
docstring: None,
name: name.1.clone(),
variants: frozen_variants
})
}
/*
EnumVariant { .. } => {}
Settings { .. } => {}
Struct { .. } => {}
Protocol { .. } => {}
Function { .. } => {}
Error { .. } => {}
*/
#[allow(unused)]
Validator {
docstring, properties,
name, expression_block
} => {
let properties = to_properties(properties);
let expr_block = Box::new(FrozenUnit::ExpressionBlock { function_calls: vec![] });
return Ok(FrozenUnit::Validator {
docstring: Some("".to_owned()), // TODO: Docstrings should likely be a vector of units
properties: vec![],
name: name.1.clone(),
expression_block: expr_block
})
}
/*
Field { .. } => {}
Parameter { .. } => {}
Property { .. } => {}
ExpressionBlock { .. } => {}
*/
missing => unimplemented!("Missing implementation for node '{:?}'", missing)
}
panic!()
}
#[allow(unused)]
fn to_properties(nodes: &Vec<SpannedUnit>) -> Vec<FrozenUnit> {
let properties = vec![];
for node in nodes {
}
properties
}
pub fn into_frozen_unit() -> FrozenUnit {
todo!()
}

26
core/src/schema/ir/compiler/interpreter/semi_frozen.rs
View file

@ -6,10 +6,28 @@ use crate::utils::codemap::Span;
// External Uses
#[derive(Clone)]
pub enum SemiFrozenUnit {
Constant {
name: (Span, String)
},
pub struct Import {
pub(crate) namespace: (Span, String),
// TODO: Alias of imports for schemas, objects, etc, is needed for namespace conflicts
// pub(crate) alias: (Span, String)
}
// TODO: All of these structures might be able to be replace with a single one, since
// a lot of them might just need to have a name and span to the objects
#[derive(Clone)]
pub struct Structure {
pub(crate) name: (Span, String)
}
#[derive(Clone)]
pub struct Constant {
pub(crate) name: (Span, String)
}
#[derive(Clone)]
pub struct Protocol {
pub(crate) name: (Span, String)
}

4
core/src/schema/ir/compiler/mod.rs
View file

@ -7,7 +7,7 @@ pub mod report;
// Local Uses
use crate::schema::idl::parser_new;
use crate::schema::idl::ast::unit::{ASTUnit, SourcedWhole};
use crate::schema::idl::ast::unit::{ASTUnit, SourcedWholeRc};
// External Uses
@ -29,5 +29,5 @@ pub trait Compile {
}
fn from_sourced_whole(sourced: SourcedWhole) -> Self::Output;
fn from_sourced_whole(sourced: SourcedWholeRc) -> Self::Output;
}

62
core/src/schema/ir/compiler/report.rs
View file

@ -1,47 +1,63 @@
// Standard Uses
use std::fmt::{Display, Formatter};
// Crate Uses
use crate::report::ReportDetails;
// External Uses
use snafu::Snafu;
use strum::EnumProperty;
use strum_macros::FromRepr;
// TODO: repr(u16) is here so we could turn a enum variant instance into its corresponding number
// however i didn't find how to do it without having to match pattern every each one of
// the variants and return the number by casting the variant, so strum props were used.
// If in the future we know of a better solution, it should be applied
#[repr(u16)]
#[derive(EnumProperty)]
#[derive(Debug, Snafu)]
pub enum CompileError {
#[strum(props(Id="1"))]
#[snafu(display("Found namespace '{target}' when its already declared in '{origin}'"))]
Namespace { source: std::io::Error, origin: String, target: String } = 1,
#[snafu(display(
"Found namespace '{target}' when its already declared in '{origin}'"
))]
NamespaceCollision { origin: String, target: String } = 0,
#[snafu(display("No type found by name '{name}'"))]
TypeNotFound { name: String },
}
impl CompileError {
pub fn code(&self) -> u16 {
self.get_str("Id").expect("Variant does not have a 'Id' property").parse().unwrap()
}
}
impl Display for ReportDetails<CompileError> {
#[allow(unused)]
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "TODO: Display needs implementation here")
pub(crate) fn code(&self) -> u16 {
unsafe { *<*const _>::from(self).cast::<u16>() }
}
}
// TODO: Same case as the enum `CompileError` about the repr
#[derive(EnumProperty, FromRepr)]
#[repr(u16)]
#[derive(Debug, Snafu)]
pub enum CompileWarning {
#[strum(props(Id="1"))]
#[snafu(display("No dependencies were assigned, this will automatically add Comline's langlib'"))]
DependenciesNotFilled
}
impl CompileWarning {
pub(crate) fn code(&self) -> u16 {
unsafe { *<*const _>::from(self).cast::<u16>() }
}
}
#[derive(Debug, Snafu)]
#[snafu(visibility(pub(crate)))]
pub enum Report {
#[snafu(display(
"Error[E0{}]: {source}\nAt line {}:{} (position {}:{})",
source.code(), details.line.start, details.line.end, details.pos.start, details.pos.end
))]
CompileErrorError {
source: CompileError,
details: ReportDetails,
},
#[snafu(display(
"Warning[W0{}]: {source}\nAt line {}:{} (position {}:{})",
source.code(), details.line.start, details.line.end, details.pos.start, details.pos.end
))]
CompileWarningError {
source: CompileWarning,
details: ReportDetails,
},
}

35
core/src/schema/ir/context.rs
View file

@ -1,22 +1,28 @@
use std::cell::RefCell;
use std::collections::HashMap;
use std::marker::PhantomData;
use std::rc::Rc;
// Local Uses
use crate::schema::idl::ast::unit::{SourcedWhole, SpannedUnit};
use crate::schema::ir::compiler::interpreter::semi_frozen::SemiFrozenUnit;
use crate::schema::idl::ast::unit::{SourcedWholeRc, SpannedUnit};
use crate::schema::ir::compiler::interpreter::semi_frozen;
use crate::schema::ir::frozen::unit::FrozenUnit;
// External Uses
#[derive(Clone, Default)]
pub struct CompileState<'a> {
pub struct CompileState<'e> {
pub namespace: Option<String>,
pub consts: HashMap<&'a SpannedUnit, SemiFrozenUnit>
pub imports: HashMap<Rc<SpannedUnit>, semi_frozen::Import>,
pub consts: HashMap<Rc<SpannedUnit>, semi_frozen::Constant>,
pub structures: HashMap<Rc<SpannedUnit>, semi_frozen::Structure>,
pub protocols: HashMap<Rc<SpannedUnit>, semi_frozen::Protocol>,
pub phantom: PhantomData<&'e ()>,
}
#[allow(unused)]
impl<'a> CompileState<'_> {
impl<'e> CompileState<'_> {
pub(crate) fn to_frozen(&self) -> Vec<FrozenUnit> {
let mut interpreted = vec![];
@ -27,7 +33,8 @@ impl<'a> CompileState<'_> {
}
pub struct SchemaContext<'a> {
pub schema: SourcedWhole,
pub name: String,
pub schema: SourcedWholeRc,
pub frozen_schema: Option<Vec<FrozenUnit>>,
// pub project_context: Option<&'a RefCell<ProjectContext<'a>>>,
// pub project_context: Option<&'a mut ProjectContext<'a>>,
@ -37,8 +44,9 @@ pub struct SchemaContext<'a> {
#[allow(unused)]
impl<'a> SchemaContext<'a> {
pub fn with_main(schema: SourcedWhole) -> Self{
pub fn with_main(schema: SourcedWholeRc, name: String) -> Self{
Self {
name,
schema,
frozen_schema: None,
// project_context: None,
@ -47,10 +55,12 @@ impl<'a> SchemaContext<'a> {
}
pub fn with_project_and_main(
schema: SourcedWhole,
schema: SourcedWholeRc,
// project: &'a RefCell<ProjectContext<'a>>
name: String
) -> Self {
Self {
name,
schema,
frozen_schema: None,
// project_context: Some(project),
@ -58,15 +68,6 @@ impl<'a> SchemaContext<'a> {
}
}
pub fn with_main_no_std(schema: SourcedWhole) -> Self{
Self {
schema,
frozen_schema: None,
// project_context: None,
compile_state: Default::default(),
}
}
pub(crate) fn sanitize_units(self) {
todo!()
}

6
core/src/schema/ir/diff/mod.rs
View file

@ -3,7 +3,7 @@ use std::fmt::Debug;
// Crate Uses
use crate::schema::ir::frozen::unit::{FrozenUnit, FrozenWhole};
use crate::schema::ir::compiler::interpreted::primitive::KindValue;
use crate::schema::ir::compiler::interpreted::kind_search::KindValue;
// External Uses
use downcast_rs::{Downcast, impl_downcast};
@ -18,8 +18,8 @@ pub trait Differ: Downcast + Debug {
&mut self, name: &str, left_kind_value: &KindValue, right_kind_value: &KindValue
);
fn differ(
&self, previous: &Vec<FrozenUnit>, next: &FrozenWhole,
fn differ<'a>(
&self, previous: &Vec<FrozenUnit>, next: &FrozenWhole<'a>,
document_gen: bool, auto_version: bool
) {
todo!()

17
core/src/schema/ir/frozen/unit.rs
View file

@ -2,13 +2,15 @@
// Crate Uses
use crate::schema::ir::context::SchemaContext;
use crate::schema::ir::compiler::interpreted::primitive::KindValue;
use crate::schema::ir::compiler::interpreted::kind_search::KindValue;
// External Uses
pub type FrozenWhole<'a> = (SchemaContext<'a>, Vec<FrozenUnit>);
// TODO: A lot of string instances could be &'a str, boxes could also get ditched, etc
#[derive(Deserialize, Serialize)]
#[derive(Debug, Eq, PartialEq)]
pub enum FrozenUnit {
@ -60,9 +62,9 @@ pub enum FrozenUnit {
docstring: String,
name: String,
synchronous: bool,
direction: Box<FrozenUnit>,
arguments: Vec<FrozenUnit>,
returns: Vec<FrozenUnit>,
// direction: Box<FrozenUnit>,
arguments: Vec<FrozenArgument>,
returns: Vec<KindValue>,
throws: Vec<FrozenUnit>
},
Error {
@ -86,3 +88,10 @@ pub enum FrozenUnit {
kind_value: KindValue,
}
}
#[derive(Deserialize, Serialize)]
#[derive(Debug, Eq, PartialEq)]
pub struct FrozenArgument {
pub name: String,
pub kind: KindValue
}

2
core/tests/autodoc/mod.rs
View file

@ -6,7 +6,7 @@ use comline::schema::ir::frozen::unit::FrozenUnit;
// External Uses
use once_cell::sync::Lazy;
use comline::autodoc;
use comline::schema::ir::compiler::interpreted::primitive::{KindValue, Primitive};
use comline::schema::ir::compiler::interpreted::kind_search::{KindValue, Primitive};
static PREVIOUS_FROZEN_UNITS: Lazy<Vec<FrozenUnit>> = Lazy::new(||

6
core/tests/idl/unit.rs
View file

@ -5,8 +5,8 @@ use std::path::Path;
// External Uses
use comline::schema::{idl, ir};
use comline::schema::idl::constants::SCHEMA_EXTENSION;
use comline::schema::idl::ast::unit::ASTUnit;
use comline::schema::idl::constants::SCHEMA_EXTENSION;
use comline::utils::codemap::Span;
@ -193,7 +193,9 @@ fn compile_unit() {
let path = Path::new(path);
let unit = idl::parser_new::from_path(path).unwrap();
let context = ir::context::SchemaContext::with_main(unit);
let context = ir::context::SchemaContext::with_main(
unit, path.file_stem().unwrap().to_str().unwrap().to_owned()
);
/*
let frozen_unit = interpreter::interpret_context(context).unwrap();

2
core/tests/package/test/config.idp
View file

@ -3,10 +3,12 @@ specification_version = 1
schema_paths = [
"ping.ids"
"health.ids"
]
code_generation = {
languages = {
python#3.11.0 = { package_versions=[all] }
rust#1.70.0 = { package_versions=[all] }
}
}

0
core/tests/package/test/generated/0.0.1/rust/1.70.0/health.rs
View file

14
core/tests/package/test/generated/python/3.11.0/health.py Normal file
View file

@ -0,0 +1,14 @@
# Generated code with Comline compiler and code generator
import typing
import ctypes
class HealthCheck(typing.Protocol):
def alive(self):
...
def capabilities(self):
...

16
core/tests/package/test/generated/python/3.11.0/ping.py Normal file
View file

@ -0,0 +1,16 @@
# Generated code with Comline compiler and code generator
import typing
import ctypes
LOW_PING_RATE: typing.Final[ctypes.c_uint16] = 20
class Ping(typing.Protocol):
def ping(self):
...
def ping_limit(self):
...

8
core/tests/package/test/generated/rust/1.70.0/health.rs Normal file
View file

@ -0,0 +1,8 @@
// Generated code with Comline compiler and code generator
pub trait HealthCheck {
fn alive (&self);
fn capabilities (&self);
}

10
core/tests/package/test/generated/rust/1.70.0/ping.rs Normal file
View file

@ -0,0 +1,10 @@
// Generated code with Comline compiler and code generator
pub const LOW_PING_RATE: u16 = 20;
pub trait Ping {
fn ping (&self);
fn ping_limit (&self);
}

6
core/tests/package/test/health.ids
View file

@ -2,13 +2,13 @@
namespace test::idl::health
struct Capabilities {
names: str[]
names: str
}
/// Health check an address
@provider=Any
protocol HealthCheck {
function alive() -> bool
function capabilities() -> Capabilities
function alive() -> bool;
function capabilities() -> Capabilities;
}

10
core/tests/package/test/ping.ids
View file

@ -1,15 +1,17 @@
// Ping Schema
namespace tests::idl::ping
namespace test::idl::ping
const LOW_PING_RATE:u16 = 20;
import test::idl::health
const LOW_PING_RATE: u16 = 20
/// Ping another address
@provider=Any
protocol Ping {
function ping() -> bool
function ping() -> bool;
@timeout_ms=1000
function ping_limit() -> bool
function ping_limit() -> bool;
}