lua-annotations 0.1.0__py3-none-any.whl

lua_annotations/api/annotations.py

@@ -0,0 +1,123 @@
+from dataclasses import dataclass, field
+from graphlib import TopologicalSorter
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Literal, Optional
+
+ENVIRONMENTS = ('client', 'server', 'shared')
+
+if TYPE_CHECKING:
+    from lua_annotations.build_process import BuildProcessCtx, PostProcessCtx
+    from lua_annotations.parser_schemas import Annotation
+    from parser import FileParser
+
+ARG_SEP = ', '
+
+type retention = Literal['build', 'init', 'runtime']
+type scope = Literal['module', 'method', 'type', 'returned_value']
+type argProcessor = Callable[[str], Any]
+
+@dataclass
+class AnnotationBuildCtx():
+    annotation: 'Annotation'
+    parser: 'FileParser'
+    build_ctx: 'BuildProcessCtx'
+
+type OnBuild = Callable[[AnnotationBuildCtx], None]
+
+#for extensions to define annotations
+@dataclass
+class AnnotationDef():
+    """An annotation definition; all Annotation classes are attached to one of these."""
+    name: str
+    args: list[argProcessor]=field(default_factory=list)
+    kwargs: dict[str, argProcessor]=field(default_factory=dict)
+    retention: retention='build'
+    scope: scope='module'
+    mutual_include: list['AnnotationDef']=field(default_factory=list)
+    mutual_exclude: list['AnnotationDef']=field(default_factory=list)
+    on_build: Optional[OnBuild]=None
+    extends: list['AnnotationDef']=field(default_factory=list)
+    
+
+@dataclass
+class FileBuildCtx():
+    build_ctx: 'BuildProcessCtx'
+    parser: 'FileParser'
+    filepath: Path
+
+type FileBuildHook = Callable[[FileBuildCtx], None]
+type PostBuildHook =  Callable[[PostProcessCtx], None]
+
+class Extension():
+    def on_post_process(self, ctx: PostProcessCtx):
+        ...
+    def on_file_process(self, ctx: FileBuildCtx):
+        ...
+    def load(self, ctx: ExtensionRegistry):
+        ...
+
+
+@dataclass
+class SortedRegistry():
+    """Topologically sorted file_build_hooks and post_build_hooks"""
+    file_build_hooks: list[FileBuildHook]
+    post_build_hooks: list[PostBuildHook]
+    anot_registry: dict[str, AnnotationDef]
+
+class ExtensionRegistry():
+    """Provides an API to register and get extensions"""
+
+    def __init__(self):
+        self.anot_registry: dict[str, AnnotationDef] = {}
+        self.extensions: dict[str, Extension] = {}
+        self.ext_graph: dict[str, list[str]] = {}
+        self.ext_load_order: list[str] = []
+
+
+    def register_extension(self, extension: Extension, deps: list[str] = [], hook_order: Literal['before', 'after']='after'):
+        name = type(extension).__name__
+        extension.hook_order = hook_order
+        self.extensions[name] = extension
+        self.ext_graph[name] = deps
+
+    
+    def register_anot(self, anot: AnnotationDef):
+        self.anot_registry[anot.name] = anot
+
+
+    def sort_extensions(self):
+        ext_layers = [[self.extensions[ext] for ext in layer] for layer in topo_layers(self.ext_graph)]
+        load_exts = [x for y in ext_layers for x in y]
+        hook_exts = [x for y in shift_exts(ext_layers) for x in y]
+
+        for ext in load_exts:
+            ext.load(self)
+
+        return SortedRegistry(
+            [ext.on_file_process for ext in hook_exts],
+            [ext.on_post_process for ext in hook_exts],
+            self.anot_registry
+        )
+
+def shift_exts(layers: list[list[Extension]], flag: str='before'):
+    befores = []
+    for layer in layers:
+        befores += [e for e in layer if e.hook_order == flag]
+        layer[:] = [e for e in layer if e.hook_order != flag]
+
+    if befores:
+        layers[0][:0] = befores
+
+    return layers
+
+def topo_layers(graph: dict[str, list[str]]):
+    ts = TopologicalSorter(graph)
+    ts.prepare()
+
+    layers: list[list[str]] = []
+    while ts.is_active():
+        ready = list(ts.get_ready())
+        ready.sort()
+        layers.append(list(ready))
+        ts.done(*ready)
+    return layers

lua_annotations/api/arguments.py

@@ -0,0 +1,26 @@
+from lua_annotations.exceptions import ParseError
+
+#[val1, val2, val3]
+def list_arg(string: str) -> list[str]:
+    """Converts a string wrapped in [] and seperated by commas into a python list"""
+    if not (string.startswith('[') and string.endswith(']')):
+        raise ParseError('list argument must be wrapped in `[` and `]` characters')
+    string = string[1:-1]
+    if string.strip() == '':
+        return []
+
+    return [s.strip() for s in string.split(',')]
+
+def default_list(str: str):
+    """Tries to call list_arg, but if the argument cannot be parsed into a list, a list wrapped with the string is returned."""
+    try:
+        return list_arg(str)
+    except ParseError:
+        return [str]
+
+def literal_builder(options: list[str]):
+    def f(s: str):
+        if s not in options:
+            raise ParseError(f'{s!r} not in literal options: {options}')
+        return s
+    return f

lua_annotations/api/lua_dict.py

@@ -0,0 +1,192 @@
+from dataclasses import dataclass, field
+from pathlib import PurePath
+from typing import Any
+
+from .annotations import ENVIRONMENTS
+from lua_annotations.build_process import AUTOGENERATED_HEADER, Environment, ProcessCtx, Workspace
+
+HEADER = '-- ' + AUTOGENERATED_HEADER
+
+ENV_TO_IMPORT: dict[Environment, str] = {
+    'server': 'game:GetService("ServerScriptService")',
+    'client': 'game:GetService("Players").LocalPlayer:FindFirstChildOfClass("PlayerScripts")',
+    'shared': 'game:GetService("ReplicatedStorage")'
+}
+ENV_TO_VAR: dict[Environment, str] = {
+    'server': 'ServerScriptService',
+    'client': 'PlayerScripts',
+    'shared': 'ReplicatedStorage'
+}
+INDENT = ' ' * 4
+
+
+def convert_dict(resolver: LuaPathResolver, data: Any, indent: int = 0, sep: str = ' = ', prefix: str = 'return'):
+    def table_block(entry_lines: list[str], level: int) -> str:
+        if len(entry_lines) == 0:
+            return '{}'
+        inner = INDENT * (level + 1)
+        outer = INDENT * level
+        return '\n'.join(
+            ['{', *(f'{inner}{line}' for line in entry_lines), f'{outer}}}']
+        )
+
+    def process_dict(value: dict[Any,Any], level: int):
+        entries = [
+            f'{key_to_lua(k, level)}{sep}{to_lua(v, level + 1)},'
+            for k, v in value.items()
+        ]
+        return table_block(entries, level)
+
+
+    def to_lua(value: Any, level: int):
+        if isinstance(value, object):
+            if isinstance(value, LuaExpr):
+                return value.string
+
+            if isinstance(value, LuaPath):
+                return value.to_lua(resolver)
+            
+            if hasattr(value, 'asdict') and callable(value.asdict):
+                return process_dict(value.asdict(), level)
+
+        if isinstance(value, dict):
+            return process_dict(value, level)
+
+        if isinstance(value, (list, tuple)):
+            entries = [f'{to_lua(item, level + 1)},' for item in value]
+            return table_block(entries, level)
+
+        if isinstance(value, str):
+            escaped = value.replace('\\', '\\\\').replace('"', '\\"')
+            return f'"{escaped}"'
+
+        if isinstance(value, bool):
+            return 'true' if value else 'false'
+
+        if value is None:
+            return 'nil'
+
+        return str(value)
+
+    def key_to_lua(key: Any, level: int):
+        if isinstance(key, str) and key.isidentifier():
+            return key
+        return f'[{to_lua(key, level)}]'
+
+    body = to_lua(data, indent)
+    import_lines = resolver.get_import_lines()
+
+    parts: list[str] = []
+    if import_lines:
+        parts += ['\n'.join(import_lines), '']
+    parts.append(f'{prefix} {body}')
+
+    return '\n'.join(parts) + '\n'
+
+
+class LuaPathResolver:
+    """Resolves lua paths and stores required imports; one should be created per output file."""
+    def __init__(self, workspace: Workspace):
+        self.workspace = workspace
+        self.used_imports: set[Environment] = set()
+
+    def _resolve_expr(self, env: Environment, raw_expr: str, inline_require: bool = False):
+        map = ENV_TO_IMPORT if inline_require else ENV_TO_VAR
+        #require(:Packages.default_extension): -> require(ServerScriptService.Packages.default_extension).example.path)
+        return raw_expr.replace(':', f'{map[env]}.', 1)
+
+    def normalize(self, path: PurePath, inline_require: bool = False) -> tuple[Environment, PurePath, str]:
+        # path is relative an env workdir
+        for env, path_map in self.workspace.items():
+            for workdir, lua_expr in path_map.items():
+                try:
+                    relative = path.relative_to(workdir)
+                    return env, relative, self._resolve_expr(env, lua_expr, inline_require)
+                except ValueError:
+                    continue
+
+        # path is prefixed with an env name
+        parts = [part for part in path.parts if part not in ('', '.', '/')]
+        if parts and parts[0] in self.workspace:
+            env = parts[0]  # type: ignore[assignment]
+            return env, PurePath(*parts[1:]), ENV_TO_VAR[env]
+
+        raise ValueError(f'Unknown lua path: {path}')
+
+    def mark_used(self, env: Environment) -> None:
+        self.used_imports.add(env)
+
+    def get_import_lines(self):
+        import_lines: list[str] = []
+
+        for env in ENVIRONMENTS:
+            if env in self.used_imports:
+                import_lines.append(f'local {ENV_TO_VAR[env]} = {ENV_TO_IMPORT[env]}')
+
+        return import_lines
+
+
+@dataclass
+class LuaExpr:
+    """Tiny wrapper class to represent a lua expression literal.
+    When used with the `convert_dict` api, the value is not wrapped with quotes in the lua output."""
+    string: str
+
+
+@dataclass
+class LuaPath:
+    """A class which allows for easy conversion of a pathlib path into a lua expression. Note that any non-relative paths require a LuaPathResolver."""
+    path: PurePath
+    relative: bool=False
+    require: bool=False
+    properties: list[str]=field(default_factory=list)
+    function: bool=False
+
+    def _parts_no_ext(self, p: PurePath):
+        return [x for x in p.with_suffix('').parts if x not in ('', '.')]
+
+    def _post_process(self, string: str):
+        if self.require or len(self.properties) > 0:
+            string = f'require({string})'
+        
+        for prop in self.properties:
+            string += '.' + prop
+
+        string = string.replace('..', '.')
+
+        if self.function or (len(self.properties) > 0 and not self.require):
+            #if require is false, wrap the require path in a function
+            return f'function() return {string} end'
+        
+        return string
+
+    def to_lua_relative(self):
+        assert self.relative
+
+        #relative path (script.Parent.Example.Path)
+        parts = self._parts_no_ext(self.path)
+        expr = '.'.join(['script', 'Parent', *parts])
+        return self._post_process(expr)
+
+    def to_lua(self, resolver: LuaPathResolver, inline_require: bool = False):
+        if self.relative:
+            return self.to_lua_relative()
+
+        #env path (ReplicatedStorage.Example.Path)
+        env, rel, expr_root = resolver.normalize(self.path, inline_require)
+        if not inline_require:
+            resolver.mark_used(env)
+
+        parts = self._parts_no_ext(rel)
+        expr = '.'.join([expr_root, *parts])
+        return self._post_process(expr)
+
+
+#public api
+def convert_dict_module(ctx: ProcessCtx, data: Any, indent: int = 0):
+    dict_str = convert_dict(LuaPathResolver(ctx.workspace), data, indent)
+    return f'{HEADER}\n{dict_str}'
+
+def convert_dict_type(ctx: ProcessCtx, data: dict[str, Any], type_name: str, indent: int = 0):
+    dict_str = convert_dict(LuaPathResolver(ctx.workspace), data, indent, sep=': ', prefix = f'export type {type_name} = ')
+    return f'{HEADER}\n{dict_str}'

lua_annotations/build_process.py

@@ -0,0 +1,99 @@
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any, Literal
+from importlib.resources import files
+
+from .api.annotations import FileBuildCtx, SortedRegistry
+from .exceptions import BuildError
+from .parser_schemas import ANNOTATION_PREFIX
+
+type Environment = Literal['server', 'client', 'shared']
+FILENAMES = ['*.lua', '*.luau']
+
+AUTOGENERATED_HEADER = 'Generated using lua-anot; do not edit manually.'
+
+def get_template(name: str):
+    root = files('lua_annotations')
+    path = root / 'templates' / name
+    return path.read_text()
+
+@dataclass
+class FileBuildError(BuildError):
+    message: str
+    file: Path
+    workdir: Path
+
+    def __post_init__(self):
+        super().__init__(self.message)
+
+@dataclass
+class ProcessCtx():
+    reg: SortedRegistry
+    root_dir: Path
+    workspace: Workspace
+
+    def error(self, message: str, file: Path):
+        raise FileBuildError(message, file, self.root_dir)
+
+type BuildCtxList = dict[Environment, BuildProcessCtx]
+
+@dataclass
+class PostProcessCtx(ProcessCtx):
+    build_ctxs: BuildCtxList
+
+    def create_file(self, env: Environment, name: str, text: str):
+        self.build_ctxs[env].create_file(name, text)
+
+    def dump_json(self, env: Environment, name: str, data: dict[Any, Any]):
+        out = {'_comment': AUTOGENERATED_HEADER} | data
+        self.create_file(env, name, json.dumps(out, indent=4))
+
+@dataclass
+class BuildProcessCtx(ProcessCtx):
+    workdirs: dict[Path, str]
+    output_root: Path
+    env: Environment
+
+    def create_file(self, name: str, text: str):
+        file = self.output_root / name
+        file.parent.mkdir(parents=True, exist_ok=True)
+        file.write_text(text)
+        
+        return file
+
+    def process_file(self, file: Path):
+        from .parser import FileParser
+
+        with file.open('r') as f:
+            text = f.read()
+            if ANNOTATION_PREFIX in text:
+                parser = FileParser(self.reg, file, self)
+                parser.parse(text)
+
+                #post-file
+                for hook in self.reg.file_build_hooks:
+                    hook(FileBuildCtx(self, parser, file))
+
+                return parser
+
+    def process_dir(self, dir: Path):
+        for filename in FILENAMES:
+            matched_files = dir.rglob(filename)
+            for file in matched_files:
+                self.process_file(file)
+
+
+type RawWorkspace = dict[Environment, dict[str, str]]
+type Workspace = dict[Environment, dict[Path, str]]
+
+type Extension = tuple[Literal['library', 'path'], str]
+
+class Config():
+    def __init__(self, data: dict[Any, Any]):
+        self.out_dir_name = data.get('outDirName', 'Generated')
+
+        self.workspaces: list[RawWorkspace] = data.get('workspaces', [])
+
+        #extensions
+        self.extensions: list[Extension] = data.get('extensions', [])

lua_annotations/exceptions.py

@@ -0,0 +1,14 @@
+class LuaAnnotationsError(Exception):
+    """Base class for general Lua Annotations errors."""
+
+
+class BuildError(LuaAnnotationsError):
+    """Raised for general build-time errors"""
+
+
+class ConfigError(LuaAnnotationsError):
+    """Raised for invalid project configuration."""
+
+
+class ParseError(LuaAnnotationsError):
+    """Raised for invalid user-provided text."""

lua_annotations/extensions/default.py

@@ -0,0 +1,76 @@
+from typing import Any
+
+from lua_annotations.api.annotations import ENVIRONMENTS, AnnotationBuildCtx, AnnotationDef, ExtensionRegistry, Extension, FileBuildCtx
+from lua_annotations.build_process import Environment, PostProcessCtx, get_template
+from lua_annotations.parser_schemas import LuaMethod
+from lua_annotations.api.lua_dict import LuaPathResolver, convert_dict
+
+
+class ManifestExtension(Extension):
+    def __init__(self):
+        self.manifest: dict[Environment, dict[Any, Any]] = {env: {} for env in ENVIRONMENTS}
+        for env in ENVIRONMENTS:
+            self.manifest[env]['anot_hooks'] = {}
+            self.manifest[env]['init_hooks'] = []
+            self.manifest[env]['post_init_hooks'] = []
+            self.manifest[env]['annotations'] = []
+
+    def on_build_post_init(self, ctx: AnnotationBuildCtx, key: str):
+        adornee = ctx.annotation.adornee
+        assert isinstance(adornee, LuaMethod)
+
+        self.manifest[ctx.build_ctx.env][key].append(adornee.get_path(require=True))
+
+    def on_build_annotation_init(self, ctx: AnnotationBuildCtx):
+        adornee = ctx.annotation.adornee
+        assert isinstance(adornee, LuaMethod)
+
+        self.manifest[ctx.build_ctx.env]['anot_hooks'][ctx.annotation.adornee.name] = adornee.get_path(require=True)
+
+    def load(self, ctx: ExtensionRegistry):
+        ctx.register_anot(AnnotationDef(
+            name='onInit',
+            scope='method',
+            on_build=lambda ctx: self.on_build_post_init(ctx, 'init_hooks')
+        ))
+        ctx.register_anot(AnnotationDef(
+            'onPostInit',
+            scope='method',
+            on_build=lambda ctx: self.on_build_post_init(ctx, 'post_init_hooks')
+        ))
+        ctx.register_anot(AnnotationDef(
+            name='annotationInit',
+            scope='method',
+            on_build=self.on_build_annotation_init
+        ))
+
+        #annotation to literally just mark a module to be parsed.
+        ctx.register_anot(AnnotationDef(
+            name='module',
+            scope='module'
+        ))
+
+    def on_file_process(self, ctx: FileBuildCtx):
+        for anot in ctx.parser.annotations:
+            if anot.adef.retention != 'build':
+                self.manifest[ctx.build_ctx.env]['annotations'].append(anot)
+
+    def on_post_process(self, ctx: PostProcessCtx):
+        for env in ('server', 'client'):
+            template = get_template('AnnotationInit.lua')
+
+            for key in ('annotations', 'anot_hooks', 'init_hooks', 'post_init_hooks'):
+                if isinstance(self.manifest[env][key], dict):
+                    self.manifest[env][key] |= self.manifest['shared'][key]
+                else:
+                    self.manifest[env][key] += self.manifest['shared'][key]
+            data =  self.manifest[env]
+
+            converted = convert_dict(LuaPathResolver(ctx.workspace), data, prefix = 'local manifest =')
+            out = template.replace('--manifest', converted)
+
+            ctx.create_file(env, f'AnnotationInit.{env}.lua', out)
+
+
+def load(ctx: ExtensionRegistry):
+    ctx.register_extension(ManifestExtension())

lua_annotations/extensions/game_framework/index.py

@@ -0,0 +1,84 @@
+from lua_annotations.api.annotations import ENVIRONMENTS, AnnotationBuildCtx, AnnotationDef, Extension, ExtensionRegistry
+from lua_annotations.api.lua_dict import HEADER, LuaPath, LuaPathResolver, convert_dict_module
+from lua_annotations.build_process import Environment, PostProcessCtx
+from lua_annotations.parser_schemas import LuaType, ReturnedValue
+
+
+def _env(ctx: AnnotationBuildCtx):
+    return ctx.build_ctx.env
+def _name(ctx: AnnotationBuildCtx):
+    return ctx.annotation.kwargs_val.get('name')
+
+
+class IndexExtension(Extension):
+    def __init__(self) -> None:
+        self.indexes: dict[Environment, dict[str, LuaPath]]                     = {env: {} for env in ENVIRONMENTS}
+        self.exported_types: dict[Environment, list[tuple[LuaPath, str]]]       = {env: [] for env in ENVIRONMENTS}
+        self.indexed_types: dict[Environment, list[tuple[LuaPath, str, str]]]   = {env: [] for env in ENVIRONMENTS}
+
+
+    def on_post_process(self, ctx: PostProcessCtx):
+        for env in ENVIRONMENTS:
+            # module index
+            ctx.create_file(env, 'Index.lua', convert_dict_module(ctx, self.indexes[env]))
+
+            # type index
+            resolver = LuaPathResolver(ctx.workspace)
+            imports: dict[str, str] = {}
+            type_lines: list[str] = []
+
+            for path, type_name in self.exported_types[env]:
+                type_lines.append(f'export type {type_name} = typeof({path.to_lua(resolver)})')
+
+            for path, type_name, module_name in self.indexed_types[env]:
+                imports.setdefault(module_name, f'local {module_name} = {path.to_lua(resolver)}')
+                type_lines.append(f'export type {type_name} = {module_name}.{type_name}')
+
+            # build final file
+            out = (
+                [HEADER]
+                + resolver.get_import_lines()
+                + ['']
+                + list(imports.values())
+                + type_lines
+                + ['', 'return nil']
+            )
+            ctx.create_file(env, 'Types/Index.lua', '\n'.join(out))
+
+
+    def on_build_indexed(self, ctx: AnnotationBuildCtx):
+        module = ctx.annotation.adornee
+        assert isinstance(module, ReturnedValue)
+
+        dict = self.indexes[_env(ctx)]
+        key = _name(ctx) or module.returned_name
+        value = module.get_path(require=True)
+
+        argval = ctx.annotation.args_val
+        if argval:
+            dict.setdefault(argval[0], {})
+            dict[argval[0]][key] = value
+        else:
+            dict[key] = value
+
+
+    def on_build_export_type(self, ctx: AnnotationBuildCtx):
+        module = ctx.annotation.adornee
+        assert isinstance(module, ReturnedValue)
+
+        self.exported_types[_env(ctx)].append((module.get_path(require=True), _name(ctx) or module.returned_name))
+
+
+    def on_build_indexed_type(self, ctx: AnnotationBuildCtx):
+        lua_type = ctx.annotation.adornee
+        assert isinstance(lua_type, LuaType)
+        assert lua_type.exported
+
+        path = LuaPath(ctx.parser.file, require=True)
+        self.indexed_types[_env(ctx)].append((path, _name(ctx) or lua_type.name, ctx.parser.file_name))
+
+
+    def load(self, ctx: ExtensionRegistry) -> None:
+        ctx.register_anot(AnnotationDef('indexedType', scope='type',           kwargs={'name': str}, on_build=self.on_build_indexed_type))
+        ctx.register_anot(AnnotationDef('exportType',  scope='returned_value', kwargs={'name': str}, on_build=self.on_build_export_type))
+        ctx.register_anot(AnnotationDef('indexed',     scope='returned_value', kwargs={'name': str}, args=[str], on_build=self.on_build_indexed))

lua_annotations/extensions/game_framework/lifecycle.py

@@ -0,0 +1,60 @@
+from graphlib import CycleError, TopologicalSorter
+from typing import TYPE_CHECKING
+
+from lua_annotations.api.annotations import ENVIRONMENTS, AnnotationBuildCtx, AnnotationDef, ExtensionRegistry, Extension, scope
+from lua_annotations.api.arguments import default_list
+from lua_annotations.build_process import Environment, PostProcessCtx
+from lua_annotations.exceptions import BuildError
+from lua_annotations.parser_schemas import Annotation
+
+if TYPE_CHECKING:
+    from lua_annotations.extensions.default import ManifestExtension
+
+
+def filter_deps(deps: list[str]):
+    return [d for d in deps if ':' not in d]
+
+
+def proc_deps(deps: list[str]):
+    out = {'services': [], 'remotes': []}
+    for dep in deps:
+        if ':' in dep:
+            out['remotes'].append(dep.split(':')[1])
+        else:
+            out['services'].append(dep)
+    return out
+
+class LifecycleExtension(Extension):
+    def __init__(self):
+        self.services: dict[Environment, list[Annotation]] = {env: [] for env in ENVIRONMENTS}
+
+    def add_service(self, ctx: AnnotationBuildCtx):
+        self.services[ctx.build_ctx.env].append(ctx.annotation)
+
+    def on_post_process(self, ctx: PostProcessCtx):
+        for env in ('server', 'client'):
+            services = self.services[env] + self.services['shared']
+
+            self.manifestExt.manifest[env]['services'] = {svc.adornee.returned_name: (
+            {
+                'depends': proc_deps(svc.kwargs_val.get('depends', [])),
+                'getAdornee': svc.adornee.get_path(function=True, require=True),
+                'kind': svc.name
+            }
+                | ({'tags': svc.args_val[0]} if svc.name == 'component' else {})
+            )
+            for svc in services}
+
+            sorter = TopologicalSorter({svc.adornee.returned_name: filter_deps(svc.kwargs_val.get('depends', {})) for svc in services})
+            
+            try:
+                self.manifestExt.manifest[env]['load_order'] = list(sorter.static_order())
+            except CycleError as e:
+                raise BuildError(f"Cycle detected for service graph: {e.args}") from e
+
+    def load(self, ctx: ExtensionRegistry):
+        self.manifestExt: ManifestExtension = ctx.extensions['ManifestExtension']
+
+        ctx.register_anot(AnnotationDef('service', retention='build', kwargs={'depends': default_list}, on_build=self.add_service))
+        ctx.register_anot(AnnotationDef('component', retention='build', args=[default_list], kwargs={'depends': default_list}, on_build=self.add_service))
+        ctx.register_anot(AnnotationDef('bindTag', retention='init', args=[default_list], scope='method'))