Feature/basic concept support

src/devana/code_generation/printers/default/__init__.py

@@ -23,3 +23,4 @@
 from .functionprinter import FunctionPrinter
 from .functiontypeprinter import FunctionTypePrinter
 from .attributeprinter import AttributePrinter, AttributeDeclarationPrinter
+from .conceptprinter import ConceptPrinter, ConceptUsagePrinter

src/devana/code_generation/printers/default/classprinter.py

@@ -181,9 +181,15 @@ def print(self, source: ClassInfo, config: Optional[PrinterConfiguration] = None
                     parameters.append(self.printer_dispatcher.print(p, config, source))
                 parameters = ','.join(parameters)
                 template_prefix = f"template<{parameters}>"
+                if source.template.requires:
+                    template_prefix += " requires"
+                    for req in source.template.requires:
+                        if isinstance(req, str):
+                            template_prefix += f" {req}"
+                            continue
+                        template_prefix += f" {self.printer_dispatcher.print(req, config, source)}"
 
                 specialisation_values = []
-
                 for s in source.template.specialisation_values:
                     if isinstance(s, str):
                         specialisation_values.append(s)

src/devana/code_generation/printers/default/conceptprinter.py

@@ -0,0 +1,39 @@
+from typing import Optional
+from devana.code_generation.printers.icodeprinter import ICodePrinter
+from devana.syntax_abstraction.conceptinfo import ConceptInfo, ConceptUsage
+from devana.code_generation.printers.dispatcherinjectable import DispatcherInjectable
+from devana.code_generation.printers.configuration import PrinterConfiguration
+from devana.code_generation.printers.formatter import Formatter
+
+
+class ConceptPrinter(ICodePrinter, DispatcherInjectable):
+    """Printer for concept definition."""
+
+    def print(self, source: ConceptInfo, config: Optional[PrinterConfiguration] = None,
+              context: Optional = None) -> str:
+        if config is None:
+            config = PrinterConfiguration()
+        formatter = Formatter(config)
+        if source.associated_comment:
+            formatter.print_line(self.printer_dispatcher.print(source.associated_comment, config, source))
+
+        parameters = [self.printer_dispatcher.print(p, config, source) for p in source.template.parameters]
+        parameters = ', '.join(parameters)
+
+        formatter.print_line(f"template<{parameters}>")
+        formatter.print_line(f"concept {source.name} = {source.body};")
+        return formatter.text
+
+class ConceptUsagePrinter(ICodePrinter, DispatcherInjectable):
+    """Printer for concept usage."""
+
+    def print(self, source: ConceptUsage, config: Optional[PrinterConfiguration] = None,
+              context: Optional = None) -> str:
+        name = "::".join((*source.namespaces, source.name))
+        if len(source.parameters) == 0:
+            return name
+
+        parameters = ', '.join(
+            self.printer_dispatcher.print(p, config, source) for p in source.parameters
+        )
+        return f"{name}<{parameters}>"

src/devana/code_generation/printers/default/defaultprinter.py

@@ -14,6 +14,8 @@
 from devana.code_generation.printers.default.commentprinter import CommentPrinter
 from devana.code_generation.printers.default.functiontypeprinter import FunctionTypePrinter
 from devana.code_generation.printers.default.stubtypeprinter import StubTypePrinter
+from devana.code_generation.printers.default.conceptprinter import ConceptPrinter, ConceptUsagePrinter
+from devana.syntax_abstraction.conceptinfo import ConceptInfo, ConceptUsage
 from devana.syntax_abstraction.classinfo import ClassInfo
 from devana.syntax_abstraction.templateinfo import GenericTypeParameter
 from devana.syntax_abstraction.typedefinfo import TypedefInfo
@@ -72,5 +74,6 @@ def create_default_printer() -> CodePrinter:
     printer.register(StubTypePrinter, StubType)
     printer.register(AttributePrinter, Attribute)
     printer.register(AttributeDeclarationPrinter, AttributeDeclaration)
-
+    printer.register(ConceptPrinter, ConceptInfo)
+    printer.register(ConceptUsagePrinter, ConceptPrinter)
     return printer

src/devana/code_generation/printers/default/functionprinter.py

@@ -41,6 +41,13 @@ def print(self, source: FunctionInfo, config: Optional[PrinterConfiguration] = N
                 parameters.append(self.printer_dispatcher.print(p, config, source))
             parameters = ','.join(parameters)
             template_prefix = f"template<{parameters}>"
+            if source.template.requires:
+                template_prefix += " requires"
+                for req in source.template.requires:
+                    if isinstance(req, str):
+                        template_prefix += f" {req}"
+                        continue
+                    template_prefix += f" {self.printer_dispatcher.print(req, config, source)}"
 
             specialisation_values = []
 
@@ -71,6 +78,13 @@ def print(self, source: FunctionInfo, config: Optional[PrinterConfiguration] = N
             result = f"{return_type} {name}{template_suffix}({args})"
         else:
             result = f"{name}{template_suffix}({args})"
+        if source.requires:
+            result += " requires"
+            for req in source.requires:
+                if isinstance(req, str):
+                    result += f" {req}"
+                    continue
+                result += f" {self.printer_dispatcher.print(req, config, source)}"
 
         if source.modification.is_static:
             result = "static " + result

src/devana/code_generation/printers/default/templateparameterprinter.py

@@ -1,14 +1,18 @@
 from devana.code_generation.printers.icodeprinter import ICodePrinter
 from devana.syntax_abstraction.templateinfo import TemplateInfo
 from devana.code_generation.printers.dispatcherinjectable import DispatcherInjectable
+from devana.syntax_abstraction.conceptinfo import ConceptUsage
 
 
 class TemplateParameterPrinter(ICodePrinter, DispatcherInjectable):
     """Printer for template parameter."""
 
     def print(self, source: TemplateInfo.TemplateParameter, _1=None, _2=None) -> str:
+        if isinstance(source.specifier, ConceptUsage):
+            text = f"{self.printer_dispatcher.print(source.specifier)} {source.name}"
+        else:
+            text = f"{source.specifier} {source.name}"
 
-        text = f"{source.specifier} {source.name}"
         if source.is_variadic:
             return f"{text}..."
         if source.default_value:

src/devana/code_generation/printers/default/usingprinter.py

@@ -21,6 +21,24 @@ def print(self, source: Using, config: Optional[PrinterConfiguration] = None,
 
         if source.associated_comment:
             formatter.print_line(self.printer_dispatcher.print(source.associated_comment, config, source))
+
+        template_prefix = ""
+        if source.template:
+            parameters = []
+            for p in source.template.parameters:
+                parameters.append(self.printer_dispatcher.print(p, config, source))
+            parameters = ','.join(parameters)
+            template_prefix = f"template<{parameters}>"
+            if source.template.requires:
+                template_prefix += " requires"
+                for req in source.template.requires:
+                    if isinstance(req, str):
+                        template_prefix += f" {req}"
+                        continue
+                    template_prefix += f" {self.printer_dispatcher.print(req, config, source)}"
+        if template_prefix:
+            formatter.print_line(template_prefix)
+
         formatter.line = f"using {source.name} = {self.printer_dispatcher.print(source.type_info, config, source)};"
         formatter.next_line()
         return formatter.text

src/devana/syntax_abstraction/classinfo.py

@@ -12,6 +12,7 @@
 from devana.syntax_abstraction.comment import Comment
 from devana.syntax_abstraction.attribute import DescriptiveByAttributes, AttributeDeclaration
 from devana.syntax_abstraction._external_source import create_external
+from devana.syntax_abstraction.conceptinfo import ConceptUsage
 from devana.utility.lazy import LazyNotInit, lazy_invoke
 from devana.utility.init_params import init_params
 from devana.utility.traits import IBasicCreatable, ICursorValidate, IFromCursorCreatable, IFromParamsCreatable
@@ -207,6 +208,7 @@ def from_params( # pylint: disable=unused-argument too-many-positional-arguments
             template: Optional[TemplateInfo] = None,
             associated_comment: Optional[Comment] = None,
             prefix: Optional[str] = None,
+            requires: Optional[List[Union[str, ConceptUsage]]] = None,
             access_specifier: Optional[AccessSpecifier] = None,
             type: Optional[MethodType] = None, # noqa pylint: disable=redefined-builtin
     ) -> "MethodInfo":
@@ -305,6 +307,7 @@ def from_params( # pylint: disable=unused-argument, arguments-renamed, too-many-
             template: Optional[TemplateInfo] = None,
             associated_comment: Optional[Comment] = None,
             prefix: Optional[str] = None,
+            requires: Optional[List[Union[str, ConceptUsage]]] = None,
             access_specifier: Optional[AccessSpecifier] = None,
             type: Optional[MethodType] = None, # noqa pylint: disable=redefined-builtin
             initializer_list: Optional[List[InitializerInfo]] = None,
@@ -416,6 +419,7 @@ def from_params(  # pylint: disable=unused-argument, arguments-differ, too-many-
             template: Optional[TemplateInfo] = None,
             associated_comment: Optional[Comment] = None,
             prefix: Optional[str] = None,
+            requires: Optional[List[Union[str, ConceptUsage]]] = None,
             access_specifier: Optional[AccessSpecifier] = None,
     ) -> "DestructorInfo":
         return cls(None, parent)