Use CamelCase for Starlark types

Author: gregmagolan

.aspect/config.axl

@@ -1,2 +1,2 @@
-def config(ctx):
+def config(ctx: ConfigContext):
     pass

crates/aspect-cli/.aspect/config.axl

@@ -1,2 +1,2 @@
-def config(ctx):
+def config(ctx: ConfigContext):
     pass

crates/axl-runtime/src/builtins/aspect/build.axl

@@ -10,7 +10,7 @@ Improvements over 'bazel build' command:
 
 load("./common.axl", "tui")
 
-def impl(ctx: task_context) -> int:
+def impl(ctx: TaskContext) -> int:
     stdout = ctx.std.io.stdout
     stderr = ctx.std.io.stderr
     events = True

crates/axl-runtime/src/builtins/aspect/common.axl

@@ -1,4 +1,4 @@
-def _fancy_tui(ctx: task_context, build) -> int:
+def _fancy_tui(ctx: TaskContext, build: bazel.build.Build) -> int:
     events = build.events()
     offset = 0
     in_flight = {}
@@ -48,7 +48,7 @@ def _fancy_tui(ctx: task_context, build) -> int:
             last_drawn_lines = len(in_flight)
             offset = (offset + 1) % len(in_flight)
 
-def _simple_tui(ctx: task_context, build) -> int:
+def _simple_tui(ctx: TaskContext, build: bazel.build.Build) -> int:
     for event in build.events():
         if event.kind == "progress":
             ctx.std.io.stdout.write(event.payload.stdout)
@@ -60,7 +60,7 @@ def _simple_tui(ctx: task_context, build) -> int:
     return exit.code
 
 
-def tui(ctx: task_context, build) -> int:
+def tui(ctx: TaskContext, build: bazel.build.Build) -> int:
     stdout = ctx.std.io.stdout
     if stdout.is_tty:
         return _fancy_tui(ctx, build)

crates/axl-runtime/src/engine/async/future.rs

@@ -36,7 +36,7 @@ impl<'v> AllocValue<'v> for Box<dyn FutureAlloc> {
 pub type FutOutput = Result<Box<dyn FutureAlloc>, anyhow::Error>;
 
 #[derive(Display, Allocative, ProvidesStaticType, NoSerialize)]
-#[display("future")]
+#[display("Future")]
 pub struct StarlarkFuture {
     #[allocative(skip)]
     inner: Rc<RefCell<Option<BoxFuture<'static, FutOutput>>>>,
@@ -82,7 +82,7 @@ unsafe impl<'v> Trace<'v> for StarlarkFuture {
 
 impl Debug for StarlarkFuture {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("StarlarkFuture").finish()
+        f.debug_struct("Future").finish()
     }
 }
 
@@ -103,7 +103,7 @@ impl<'v> UnpackValue<'v> for StarlarkFuture {
     }
 }
 
-#[starlark_value(type = "future")]
+#[starlark_value(type = "Future")]
 impl<'v> values::StarlarkValue<'v> for StarlarkFuture {
     fn get_methods() -> Option<&'static Methods> {
         static RES: MethodsStatic = MethodsStatic::new();

crates/axl-runtime/src/engine/async/future_stream.rs

@@ -15,24 +15,24 @@ use super::future::StarlarkFuture;
 use super::rt::AsyncRuntime;
 
 #[derive(ProvidesStaticType, Display, NoSerialize, Allocative)]
-#[display("<future.iter>")]
-pub struct FutureStream {
+#[display("<FutureIterator>")]
+pub struct FutureIterator {
     #[allocative(skip)]
     pub(super) rt: AsyncRuntime,
     #[allocative(skip)]
     pub(super) stream: Arc<RwLock<JoinSet<super::future::FutOutput>>>,
 }
 
-impl std::fmt::Debug for FutureStream {
+impl std::fmt::Debug for FutureIterator {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("FutureStream")
+        f.debug_struct("FutureIterator")
             .field("rt", &self.rt)
             .field("stream", &self.stream)
             .finish()
     }
 }
 
-impl FutureStream {
+impl FutureIterator {
     pub fn new(rt: AsyncRuntime, futures: Vec<StarlarkFuture>) -> Self {
         let mut set = JoinSet::new();
         let guard = rt.enter();
@@ -47,24 +47,24 @@ impl FutureStream {
     }
 }
 
-unsafe impl<'v> Trace<'v> for FutureStream {
+unsafe impl<'v> Trace<'v> for FutureIterator {
     fn trace(&mut self, _tracer: &values::Tracer<'v>) {}
 }
 
-impl Clone for FutureStream {
+impl Clone for FutureIterator {
     fn clone(&self) -> Self {
         todo!()
     }
 }
 
-impl<'v> AllocValue<'v> for FutureStream {
+impl<'v> AllocValue<'v> for FutureIterator {
     fn alloc_value(self, heap: &'v Heap) -> values::Value<'v> {
         heap.alloc_complex_no_freeze(self)
     }
 }
 
-#[starlark_value(type = "future_iter")]
-impl<'v> values::StarlarkValue<'v> for FutureStream {
+#[starlark_value(type = "FutureIterator")]
+impl<'v> values::StarlarkValue<'v> for FutureIterator {
     unsafe fn iterate(
         &self,
         me: values::Value<'v>,

crates/axl-runtime/src/engine/async/mod.rs

@@ -31,11 +31,12 @@ pub mod rt {
 }
 
 #[starlark_module]
-fn register_type_toplevels(builder: &mut GlobalsBuilder) {
-    const future: StarlarkValueAsType<future::StarlarkFuture> = StarlarkValueAsType::new();
+fn register_types(globals: &mut GlobalsBuilder) {
+    const Future: StarlarkValueAsType<future::StarlarkFuture> = StarlarkValueAsType::new();
 }
 
-pub fn register_toplevels(builder: &mut GlobalsBuilder) {
-    util::register_toplevels(builder);
-    register_type_toplevels(builder)
+pub fn register_globals(globals: &mut GlobalsBuilder) {
+    register_types(globals);
+
+    util::register_globals(globals);
 }

crates/axl-runtime/src/engine/async/util.rs

@@ -4,19 +4,19 @@ use starlark::{
 
 use crate::engine::store::AxlStore;
 
-use super::{future::StarlarkFuture, future_stream::FutureStream};
+use super::{future::StarlarkFuture, future_stream::FutureIterator};
 
-pub fn register_toplevels(builder: &mut GlobalsBuilder) {
-    builder.namespace("futures", register_future_utils);
+pub fn register_globals(globals: &mut GlobalsBuilder) {
+    globals.namespace("futures", register_future_utils);
 }
 
 #[starlark_module]
-fn register_future_utils(_: &mut GlobalsBuilder) {
+fn register_future_utils(globals: &mut GlobalsBuilder) {
     fn iter<'v>(
         #[starlark(args)] futures: UnpackTuple<StarlarkFuture>,
         eval: &mut Evaluator<'v, '_, '_>,
-    ) -> starlark::Result<FutureStream> {
+    ) -> starlark::Result<FutureIterator> {
         let store = AxlStore::from_eval(eval)?;
-        return Ok(FutureStream::new(store.rt, futures.items));
+        return Ok(FutureIterator::new(store.rt, futures.items));
     }
 }

crates/axl-runtime/src/engine/bazel/build.rs

@@ -40,7 +40,7 @@ use super::stream_sink::GrpcEventStreamSink;
 use super::stream_tracing::TracingEventStreamSink;
 
 #[derive(Debug, ProvidesStaticType, Display, Trace, NoSerialize, Allocative)]
-#[display("<build_status>")]
+#[display("<bazel.build.BuildStatus>")]
 pub struct BuildStatus {
     success: bool,
     code: Option<i32>,
@@ -52,7 +52,7 @@ impl<'v> AllocValue<'v> for BuildStatus {
     }
 }
 
-#[starlark_value(type = "build_status")]
+#[starlark_value(type = "bazel.build.BuildStatus")]
 impl<'v> values::StarlarkValue<'v> for BuildStatus {
     fn get_methods() -> Option<&'static Methods> {
         static RES: MethodsStatic = MethodsStatic::new();
@@ -75,7 +75,7 @@ pub(crate) fn build_status_methods(registry: &mut MethodsBuilder) {
 }
 
 #[derive(Debug, Display, ProvidesStaticType, NoSerialize, Allocative, Clone)]
-#[display("<build_event_sink>")]
+#[display("<bazel.build.BuildEventSink>")]
 pub enum BuildEventSink {
     Grpc {
         uri: String,
@@ -85,7 +85,7 @@ pub enum BuildEventSink {
 
 starlark_simple_value!(BuildEventSink);
 
-#[starlark_value(type = "build_event_sink")]
+#[starlark_value(type = "bazel.build.BuildEventSink")]
 impl<'v> values::StarlarkValue<'v> for BuildEventSink {}
 
 impl<'v> UnpackValue<'v> for BuildEventSink {
@@ -108,7 +108,7 @@ impl BuildEventSink {
 }
 
 #[derive(Debug, Display, ProvidesStaticType, Trace, NoSerialize, Allocative)]
-#[display("<build>")]
+#[display("<bazel.build.Build>")]
 pub struct Build {
     #[allocative(skip)]
     event_stream: RefCell<Option<EventStream>>,
@@ -214,7 +214,7 @@ impl<'v> AllocValue<'v> for Build {
     }
 }
 
-#[starlark_value(type = "build")]
+#[starlark_value(type = "bazel.build.Build")]
 impl<'v> values::StarlarkValue<'v> for Build {
     fn get_methods() -> Option<&'static Methods> {
         static RES: MethodsStatic = MethodsStatic::new();

crates/axl-runtime/src/engine/bazel/iterator.rs

@@ -27,7 +27,7 @@ use starlark::values::ValueLike;
 use crate::engine::bazel::execlog_stream::{ExecLogIterator, RetryStream};
 
 #[derive(Debug, ProvidesStaticType, Display, Trace, NoSerialize, Allocative)]
-#[display("<build_event_iterator>")]
+#[display("<bazel.build.BuildEventIterator>")]
 pub struct BuildEventIterator {
     #[allocative(skip)]
     recv: RefCell<Receiver<BuildEvent>>,
@@ -58,7 +58,7 @@ pub(crate) fn build_event_methods(registry: &mut MethodsBuilder) {
     }
 }
 
-#[starlark_value(type = "build_event_iterator")]
+#[starlark_value(type = "bazel.build.BuildEventIterator")]
 impl<'v> values::StarlarkValue<'v> for BuildEventIterator {
     fn eval_type(&self) -> Option<Ty> {
         Some(Ty::iter(
@@ -93,7 +93,7 @@ impl<'v> values::StarlarkValue<'v> for BuildEventIterator {
 }
 
 #[derive(ProvidesStaticType, Display, Trace, NoSerialize, Allocative)]
-#[display("<build_event_iterator>")]
+#[display("<bazel.build.ExecutionLogIterator>")]
 pub struct ExecutionLogIterator {
     #[allocative(skip)]
     execlog_iterator:
@@ -102,7 +102,7 @@ pub struct ExecutionLogIterator {
 
 impl Debug for ExecutionLogIterator {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ExecutionLogIterator")
+        f.debug_struct("bazel.build.ExecutionLogIterator")
             .field("execlog_iterator", &String::from("hidden"))
             .finish()
     }
@@ -128,7 +128,7 @@ impl<'v> AllocValue<'v> for ExecutionLogIterator {
     }
 }
 
-#[starlark_value(type = "build_event_iterator")]
+#[starlark_value(type = "bazel.build.ExecutionLogIterator")]
 impl<'v> values::StarlarkValue<'v> for ExecutionLogIterator {
     fn eval_type(&self) -> Option<Ty> {
         Some(Ty::iter(