go types: update core-gen, core-init and go-init to be compatible with the new language specific system

Author: MS-32154

json_explorer/codegen/core/__init__.py

@@ -17,28 +17,27 @@
 from .templates import TemplateEngine, TemplateError, get_default_template_engine
 
 __all__ = [
-    # Base classes
+    # Base generator interface
     "CodeGenerator",
     "GeneratorError",
     "GenerationResult",
-    # Schema system
+    "generate_code",
+    # Schema system - core data structures
     "Schema",
     "Field",
     "FieldType",
     "convert_analyzer_output",
     "extract_all_schemas",
-    # Naming utilities
+    # Naming utilities - language-agnostic
     "NameSanitizer",
     "NamingCase",
-    # Configuration
+    # Configuration system
     "GeneratorConfig",
     "ConfigManager",
     "ConfigError",
     "load_config",
-    # Templates
+    # Template system
     "TemplateEngine",
     "TemplateError",
     "get_default_template_engine",
-    # Main function
-    "generate_code",
 ]

json_explorer/codegen/core/generator.py

@@ -2,6 +2,7 @@
 Base generator interface for all code generation targets.
 
 Defines the contract that all language generators must implement.
+Focuses on schema-level concerns while leaving type mapping to language generators.
 """
 
 from abc import ABC, abstractmethod
@@ -11,135 +12,162 @@
 
 class GeneratorError(Exception):
     """Base exception for code generation errors."""
+
     pass
 
 
 class CodeGenerator(ABC):
     """Abstract base class for all code generators."""
-    
+
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         """Initialize generator with optional configuration."""
         self.config = config or {}
-    
+
     @property
     @abstractmethod
     def language_name(self) -> str:
         """Return the name of the target language (e.g., 'go', 'python')."""
         pass
-    
+
     @property
     @abstractmethod
     def file_extension(self) -> str:
         """Return the file extension for generated files (e.g., '.go', '.py')."""
         pass
-    
+
     @abstractmethod
     def generate(self, schemas: Dict[str, Schema], root_schema_name: str) -> str:
         """
         Generate code for all schemas.
-        
+
         Args:
             schemas: Dictionary mapping schema names to Schema objects
             root_schema_name: Name of the main/root schema
-        
+
         Returns:
             Generated code as a string
         """
         pass
-    
+
     @abstractmethod
     def generate_single_schema(self, schema: Schema) -> str:
         """
         Generate code for a single schema.
-        
+
         Args:
             schema: Schema to generate code for
-        
+
         Returns:
             Generated code for this schema only
         """
         pass
-    
-    @abstractmethod
-    def map_field_type(self, field: Field) -> str:
-        """
-        Map a field to the target language's type system.
-        
-        Args:
-            field: Field to get type for
-        
-        Returns:
-            Type name in target language
-        """
-        pass
-    
+
     def get_import_statements(self, schemas: Dict[str, Schema]) -> List[str]:
         """
         Get any required import statements for the generated code.
-        
+
         Args:
             schemas: All schemas being generated
-        
+
         Returns:
             List of import statements (can be empty)
         """
         return []
-    
+
     def get_package_declaration(self) -> Optional[str]:
         """
         Get package/namespace declaration if needed.
-        
+
         Returns:
             Package declaration string or None
         """
         return None
-    
+
     def validate_schemas(self, schemas: Dict[str, Schema]) -> List[str]:
         """
-        Validate schemas for this generator and return any warnings.
-        
+        Validate schemas for basic structural issues.
+
+        Language generators should override this to add language-specific validation.
+
         Args:
             schemas: Schemas to validate
-        
+
         Returns:
             List of warning messages (empty if no issues)
         """
         warnings = []
-        
+
         for schema in schemas.values():
+            # Check for empty schemas
+            if not schema.fields:
+                warnings.append(f"Schema '{schema.name}' has no fields")
+
+            # Check for schema-level conflicts and unknowns
             for field in schema.fields:
                 if field.type == FieldType.CONFLICT:
+                    conflicting_type_names = (
+                        [t.value for t in field.conflicting_types]
+                        if field.conflicting_types
+                        else ["unknown"]
+                    )
                     warnings.append(
-                        f"Type conflict in {schema.name}.{field.name}: "
-                        f"{[t.value for t in field.conflicting_types]}"
+                        f"Type conflict in {schema.name}.{field.name}: {conflicting_type_names}"
                     )
                 elif field.type == FieldType.UNKNOWN:
+                    warnings.append(f"Unknown type in {schema.name}.{field.name}")
+
+                # Check for missing nested schemas
+                if field.type == FieldType.OBJECT and not field.nested_schema:
                     warnings.append(
-                        f"Unknown type in {schema.name}.{field.name}"
+                        f"Object field {schema.name}.{field.name} has no nested schema"
                     )
-        
+
+                # Check for array fields with unclear element types
+                if field.type == FieldType.ARRAY:
+                    if not field.array_element_type and not field.array_element_schema:
+                        warnings.append(
+                            f"Array field {schema.name}.{field.name} has no element type information"
+                        )
+
         return warnings
-    
+
     def format_code(self, code: str) -> str:
         """
         Apply language-specific formatting to generated code.
-        
+
         Args:
             code: Raw generated code
-        
+
         Returns:
             Formatted code
         """
-        return code  # Default: no formatting
+        # Basic cleanup - remove excessive blank lines
+        lines = code.split("\n")
+        formatted_lines = []
+        blank_count = 0
+
+        for line in lines:
+            stripped = line.rstrip()
+            if not stripped:
+                blank_count += 1
+                if blank_count <= 2:  # Allow max 2 consecutive blank lines
+                    formatted_lines.append("")
+            else:
+                blank_count = 0
+                formatted_lines.append(stripped)
+
+        return "\n".join(formatted_lines)
 
 
 class GenerationResult:
     """Container for generation results and metadata."""
-    
-    def __init__(self, code: str, warnings: List[str] = None, metadata: Dict[str, Any] = None):
+
+    def __init__(
+        self, code: str, warnings: List[str] = None, metadata: Dict[str, Any] = None
+    ):
         """
         Initialize generation result.
-        
+
         Args:
             code: Generated code
             warnings: Any warnings from generation
@@ -149,52 +177,70 @@ def __init__(self, code: str, warnings: List[str] = None, metadata: Dict[str, An
         self.warnings = warnings or []
         self.metadata = metadata or {}
         self.success = True
-    
+
     @classmethod
-    def error(cls, message: str, exception: Exception = None) -> 'GenerationResult':
+    def error(cls, message: str, exception: Exception = None) -> "GenerationResult":
         """Create a failed generation result."""
         result = cls(code="")
         result.success = False
         result.error_message = message
         result.exception = exception
         return result
 
+    def add_warning(self, warning: str):
+        """Add a warning to the result."""
+        self.warnings.append(warning)
+
+    def add_metadata(self, key: str, value: Any):
+        """Add metadata to the result."""
+        self.metadata[key] = value
+
 
-def generate_code(generator: CodeGenerator, schemas: Dict[str, Schema], 
-                 root_schema_name: str) -> GenerationResult:
+def generate_code(
+    generator: CodeGenerator, schemas: Dict[str, Schema], root_schema_name: str
+) -> GenerationResult:
     """
     Generate code using the specified generator with error handling.
-    
+
     Args:
         generator: Code generator instance
         schemas: Schemas to generate code for
         root_schema_name: Name of the root schema
-    
+
     Returns:
         GenerationResult with code, warnings, and metadata
     """
     try:
-        # Validate schemas
+        # Validate schemas at the base level
         warnings = generator.validate_schemas(schemas)
-        
+
         # Generate code
         code = generator.generate(schemas, root_schema_name)
-        
+
         # Format code
         formatted_code = generator.format_code(code)
-        
+
         # Create metadata
         metadata = {
             "language": generator.language_name,
             "file_extension": generator.file_extension,
             "schema_count": len(schemas),
-            "root_schema": root_schema_name
+            "root_schema": root_schema_name,
+            "has_conflicts": any(
+                field.type == FieldType.CONFLICT
+                for schema in schemas.values()
+                for field in schema.fields
+            ),
+            "has_unknowns": any(
+                field.type == FieldType.UNKNOWN
+                for schema in schemas.values()
+                for field in schema.fields
+            ),
         }
-        
-        return GenerationResult(formatted_code, warnings, metadata)
-        
+
+        result = GenerationResult(formatted_code, warnings, metadata)
+
+        return result
+
     except Exception as e:
-        return GenerationResult.error(
-            f"Code generation failed: {str(e)}", 
-            exception=e
-        )
+        return GenerationResult.error(f"Code generation failed: {str(e)}", exception=e)