#![doc(html_logo_url = "https://sixtyfps.io/resources/logo.drawio.svg")]
#![deny(unsafe_code)]
#[cfg(feature = "proc_macro_span")]
extern crate proc_macro;
use core::future::Future;
use core::pin::Pin;
use std::cell::RefCell;
use std::rc::Rc;
pub mod builtin_macros;
pub mod diagnostics;
pub mod embedded_resources;
pub mod expression_tree;
pub mod fileaccess;
pub mod generator;
pub mod langtype;
pub mod layout;
pub mod lexer;
pub mod literals;
pub mod llr;
pub(crate) mod load_builtins;
pub mod lookup;
pub mod namedreference;
pub mod object_tree;
pub mod parser;
pub mod typeloader;
pub mod typeregister;
mod passes;
#[derive(Clone)]
pub struct CompilerConfiguration {
pub embed_resources: bool,
pub include_paths: Vec<std::path::PathBuf>,
pub style: Option<String>,
pub open_import_fallback: Option<
Rc<dyn Fn(String) -> Pin<Box<dyn Future<Output = Option<std::io::Result<String>>>>>>,
>,
pub inline_all_elements: bool,
}
impl CompilerConfiguration {
pub fn new(output_format: crate::generator::OutputFormat) -> Self {
let embed_resources = match std::env::var("SIXTYFPS_EMBED_RESOURCES") {
Ok(var) => {
var.parse().unwrap_or_else(|_|{
panic!("SIXTYFPS_EMBED_RESOURCES has incorrect value. Must be either unset, 'true' or 'false'")
})
}
Err(_) => {
match output_format {
#[cfg(feature = "rust")]
crate::generator::OutputFormat::Rust => true,
_ => false,
}
}
};
let inline_all_elements = match std::env::var("SIXTYFPS_INLINING") {
Ok(var) => {
var.parse::<bool>().unwrap_or_else(|_|{
panic!("SIXTYFPS_INLINING has incorrect value. Must be either unset, 'true' or 'false'")
})
}
Err(_) => output_format == crate::generator::OutputFormat::Interpreter,
};
Self {
embed_resources,
include_paths: Default::default(),
style: Default::default(),
open_import_fallback: Default::default(),
inline_all_elements,
}
}
}
pub async fn compile_syntax_node(
doc_node: parser::SyntaxNode,
mut diagnostics: diagnostics::BuildDiagnostics,
compiler_config: CompilerConfiguration,
) -> (object_tree::Document, diagnostics::BuildDiagnostics) {
let global_type_registry = typeregister::TypeRegister::builtin();
let type_registry =
Rc::new(RefCell::new(typeregister::TypeRegister::new(&global_type_registry)));
let doc_node: parser::syntax_nodes::Document = doc_node.into();
let mut loader =
typeloader::TypeLoader::new(global_type_registry, &compiler_config, &mut diagnostics);
let foreign_imports =
loader.load_dependencies_recursively(&doc_node, &mut diagnostics, &type_registry).await;
let doc = crate::object_tree::Document::from_node(
doc_node,
foreign_imports,
&mut diagnostics,
&type_registry,
);
if let Some((_, node)) = &*doc.root_component.child_insertion_point.borrow() {
diagnostics
.push_error("@children placeholder not allowed in the final component".into(), node)
}
if !diagnostics.has_error() {
passes::run_passes(&doc, &mut diagnostics, &mut loader, &compiler_config).await;
}
diagnostics.all_loaded_files = loader.all_files().cloned().collect();
(doc, diagnostics)
}