Clean up unused functions and imports

Author: SomeRanDev

src/cscompiler/CSCompiler.hx

@@ -152,26 +152,6 @@ class CSCompiler extends reflaxe.GenericCompiler<CSTopLevel, CSTopLevel, CSState
 		}
 	}
 
-	/**
-		Returns the content generated for the `HaxeBoot.cs`.
-
-		TODO:
-			Store `args` to use with `Sys.args()` later.
-	**/
-	function haxeBootContent(csCode: String) {
-		return StringTools.trim(
-			'
-namespace Haxe {
-	class HaxeBoot {
-		static void Main(string[] args) {
-			${csCode};
-		}
-	}
-}
-		'
-		);
-	}
-	
 	/**
 		Adds a .csproj file to the output directory.
 

src/cscompiler/ast/CSClass.hx

@@ -1,8 +1,6 @@
 package cscompiler.ast;
 
 #if(macro || cs_runtime)
-import haxe.macro.Type;
-
 /**
 	Represents a class in C#.
 

src/cscompiler/ast/CSEnum.hx

@@ -1,8 +1,6 @@
 package cscompiler.ast;
 
 #if(macro || cs_runtime)
-import haxe.macro.Type;
-
 /**
 	Represents an enum in C#.
 

src/cscompiler/ast/CSExpr.hx

@@ -1,9 +1,6 @@
 package cscompiler.ast;
 
 #if(macro || cs_runtime)
-import cscompiler.ast.CSTypePath;
-
-import haxe.macro.Expr;
 import haxe.macro.Type;
 
 /**

src/cscompiler/ast/CSModifier.hx

@@ -3,19 +3,12 @@ package cscompiler.ast;
 #if(macro || cs_runtime)
 enum CSModifier {
 	CSStatic;
-	
 	CSAbstract;
-	
 	CSVirtual;
-	
 	CSOverride;
-	
 	CSPublic;
-	
 	CSPrivate;
-	
 	CSProtected;
-	
 	CSInternal;
 }
 #end

src/cscompiler/ast/CSStatement.hx

@@ -1,8 +1,6 @@
 package cscompiler.ast;
 
 #if(macro || cs_runtime)
-import cscompiler.ast.CSExpr;
-
 import haxe.macro.Type;
 
 /**

src/cscompiler/components/CSCompiler_Class.hx

@@ -40,7 +40,6 @@ class CSCompiler_Class extends CSCompiler_Base {
 	function init(classType: ClassType) {
 		csFields = [];
 
-		final className = classType.name;
 		csClassName = compiler.compileClassName(classType);
 		csNameSpace = compiler.typeComp.getNameSpace(classType);
 	}

src/cscompiler/components/CSCompiler_Enum.hx

@@ -3,9 +3,7 @@ package cscompiler.components;
 #if(macro || cs_runtime)
 import haxe.macro.Type;
 
-import reflaxe.BaseCompiler;
 import reflaxe.data.EnumOptionData;
-import reflaxe.helpers.OperatorHelper;
 
 import cscompiler.ast.CSTopLevel;
 

src/cscompiler/components/CSCompiler_Expr.hx

@@ -4,14 +4,11 @@ package cscompiler.components;
 import cscompiler.ast.*;
 import cscompiler.ast.CSExprDef.CSInjectEntry;
 import cscompiler.ast.CSStatement;
-import cscompiler.ast.CSVar.CSVarType;
 
 import haxe.macro.Expr;
 import haxe.macro.Type;
-import haxe.macro.TypeTools;
 
 import reflaxe.compiler.TargetCodeInjection;
-import reflaxe.helpers.OperatorHelper;
 
 using reflaxe.helpers.ModuleTypeHelper;
 using reflaxe.helpers.NameMetaHelper;
@@ -462,7 +459,7 @@ class CSCompiler_Expr extends CSCompiler_Base {
 						final haxeType = {
 							#if macro
 							// This function does not exist outside of "macro" target.
-							TypeTools.fromModuleType(maybeModuleType);
+							haxe.macro.TypeTools.fromModuleType(maybeModuleType);
 							#else
 							throw "Impossible";
 							#end
@@ -497,32 +494,6 @@ class CSCompiler_Expr extends CSCompiler_Base {
 		}
 	}
 
-	/**
-		Generate a block scope from an expression.
-
-		If the typed expression is `TypedExprDef.TBlock`, then each
-		sub-expression is compiled on a new line.
-
-		Otherwise, the expression is compiled normally.
-
-		Each line of the output is preemptively tabbed.
-	**/
-	function toIndentedScope(e: TypedExpr): String {
-		return "";
-		/*
-			var el = switch(e.expr) {
-				case TBlock(el): el;
-				case _: [e];
-			}
-
-			return if(el.length == 0) {
-				"";
-			} else {
-				compiler.compileExpressionsIntoLines(el).tab();
-			}
-		 */
-	}
-	
 	/**
 		Generate an expression given a `TConstant` (from `TypedExprDef.TConst`).
 	**/
@@ -628,87 +599,6 @@ class CSCompiler_Expr extends CSCompiler_Base {
 		];
 	}
 
-	/**
-		Generate an expression given a `Unop` and typed expression (from `TypedExprDef.TUnop`).
-	**/
-	function unopToCS(op: Unop, e: TypedExpr, isPostfix: Bool): String {
-		final csExpr = compileToCSStatement(e);
-		final operatorStr = OperatorHelper.unopToString(op);
-		return isPostfix ? (csExpr + operatorStr) : (operatorStr + csExpr);
-	}
-	
-	/**
-		Generate an expression given a `FieldAccess` and typed expression (from `TypedExprDef.TField`).
-	**/
-	function fieldAccessToCS(e: TypedExpr, fa: FieldAccess): String {
-		final nameMeta: NameAndMeta = switch(fa) {
-			case FInstance(_, _, classFieldRef): classFieldRef.get();
-			case FStatic(_, classFieldRef): classFieldRef.get();
-			case FAnon(classFieldRef): classFieldRef.get();
-			case FClosure(_, classFieldRef): classFieldRef.get();
-			case FEnum(_, enumField): enumField;
-			case FDynamic(s): {
-					name: s,
-					meta: null
-				};
-		}
-		
-		return if(nameMeta.hasMeta(":native")) {
-			nameMeta.getNameOrNative();
-		} else {
-			final name = compiler.compileVarName(nameMeta.getNameOrNativeName());
-			
-			// Check if a special field access and intercept.
-			switch(fa) {
-				case FStatic(clsRef, cfRef): {
-						final cf = cfRef.get();
-						final className = compiler.compileClassName(clsRef.get());
-						// TODO: generate static access
-						// return ...
-					}
-				case FEnum(_, enumField): {
-						// TODO: generate enum access
-						// return ...
-					}
-				case _:
-			}
-			
-			final csExpr = compileToCSStatement(e);
-			
-			// Check if a special field access that requires the compiled expression.
-			switch(fa) {
-				case FAnon(classFieldRef): {
-						// TODO: generate anon struct access
-						// return ...
-					}
-				case _:
-			}
-			
-			csExpr + "." + name;
-		}
-	}
-	
-	function compileIf(condExpr: TypedExpr, ifContentExpr: TypedExpr, elseExpr: Null<TypedExpr>) {
-		var result = "if(" + compileToCSStatement(condExpr.unwrapParenthesis()) + ") {\n";
-		result += toIndentedScope(ifContentExpr);
-		if(elseExpr != null) {
-			switch(elseExpr.expr) {
-				case TIf(condExpr2, ifContentExpr2, elseExpr2): {
-						result += "\n} else " + compileIf(condExpr2, ifContentExpr2, elseExpr2);
-					}
-				case _:
-					{
-						result += "\n} else {\n";
-						result += toIndentedScope(elseExpr);
-						result += "\n}";
-					}
-			}
-		} else {
-			result += "\n}";
-		}
-		return result;
-	}
-	
 	function compileFuncArgs(args: Array<{
 		v: TVar,
 		value: Null<TypedExpr>

src/cscompiler/components/CSCompiler_Type.hx

@@ -8,7 +8,6 @@ import haxe.macro.Type;
 
 import cscompiler.ast.*;
 import cscompiler.config.Define;
-import cscompiler.config.NamespaceStyle;
 import cscompiler.config.NamespaceStyle.fromString as NamespaceStyle_fromString;
 import cscompiler.helpers.StringTools;