From 072e0629252381485f13879fd8bfba4eee059fd1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luc=C3=A0s?= <86352901+LucasVbr@users.noreply.github.com> Date: Wed, 3 Jul 2024 11:11:24 +0200 Subject: [PATCH] refactor: Edit type name for consistency --- lib/ast/print.ml | 26 ++++-- lib/ast/syntax.ml | 12 +-- lib/parser.mly | 12 +-- test/ast/print.ml | 197 ++++++++++++++++++++++++---------------- test/ressources/test.🥐 | 24 ++--- 5 files changed, 164 insertions(+), 107 deletions(-) diff --git a/lib/ast/print.ml b/lib/ast/print.ml index e326518..39c425b 100644 --- a/lib/ast/print.ml +++ b/lib/ast/print.ml @@ -4,12 +4,12 @@ open Syntax (** [string_of_type t] returns a string representation of the type [t]. *) let string_of_type = function - | Type_Integer -> "Type_Integer" - | Type_Float -> "Type_Float" - | Type_Character -> "Type_Character" - | Type_String -> "Type_String" - | Type_Boolean -> "Type_Boolean" - | Type_Void -> "Type_Void" + | IntegerType -> "IntegerType" + | FloatType -> "FloatType" + | CharacterType -> "CharacterType" + | StringType -> "StringType" + | BooleanType -> "BooleanType" + | VoidType -> "VoidType" (** [string_of_binary_operator op] returns a string representation of the binary operator [op]. *) let string_of_binary_operator = function @@ -68,4 +68,16 @@ let string_of_statement = function let string_of_source_file = function | SourceFile stmts -> let stmt_strings = List.map string_of_statement stmts in - "SourceFile([" ^ String.concat ", " stmt_strings ^ "])" \ No newline at end of file + "SourceFile([" ^ String.concat ", " stmt_strings ^ "])" + +(** The signature of the module [PRINT]. *) +module type Print = sig + val string_of_type : Syntax._type -> string + val string_of_binary_operator : Syntax.binary_operator -> string + val string_of_unary_operator : Syntax.unary_operator -> string + val string_of_literal : Syntax.literal -> string + val string_of_expression : Syntax.expression -> string + val string_of_variable_declaration : Syntax.variable_declaration -> string + val string_of_statement : Syntax.statement -> string + val string_of_source_file : Syntax.source_file -> string +end \ No newline at end of file diff --git a/lib/ast/syntax.ml b/lib/ast/syntax.ml index 82876ed..41a0fc6 100644 --- a/lib/ast/syntax.ml +++ b/lib/ast/syntax.ml @@ -1,12 +1,12 @@ (* lib/ast/syntax.ml *) type _type = - | Type_Integer - | Type_Float - | Type_Character - | Type_String - | Type_Boolean - | Type_Void + | IntegerType + | FloatType + | CharacterType + | StringType + | BooleanType + | VoidType type literal = | Integer of int diff --git a/lib/parser.mly b/lib/parser.mly index 62ec216..cdb38f1 100644 --- a/lib/parser.mly +++ b/lib/parser.mly @@ -75,12 +75,12 @@ variable_declaration: | IDENTIFIER ":" tp { VariableDeclaration($3, Identifier($1), Literal(Null)) } tp: - | INTEGER_TYPE { Type_Integer } - | FLOAT_TYPE { Type_Float } - | CHARACTER_TYPE { Type_Character } - | STRING_TYPE { Type_String } - | BOOLEAN_TYPE { Type_Boolean } - | VOID_TYPE { Type_Void } + | INTEGER_TYPE { IntegerType } + | FLOAT_TYPE { FloatType } + | CHARACTER_TYPE { CharacterType } + | STRING_TYPE { StringType } + | BOOLEAN_TYPE { BooleanType } + | VOID_TYPE { VoidType } expression: | literal { Literal($1) } diff --git a/test/ast/print.ml b/test/ast/print.ml index 6943d12..cf7bf35 100644 --- a/test/ast/print.ml +++ b/test/ast/print.ml @@ -2,100 +2,145 @@ open Alcotest open Ast.Syntax -open Ast.Print + +module To_test = struct + let _type = Ast.Print.string_of_type + let literal = Ast.Print.string_of_literal + let binary_operator = Ast.Print.string_of_binary_operator + let unary_operator = Ast.Print.string_of_unary_operator + let expression = Ast.Print.string_of_expression + let statement = Ast.Print.string_of_statement + let source_file = Ast.Print.string_of_source_file +end let test_string_of_type () = - check string "int" "Type_Integer" (string_of_type Type_Integer); - check string "float" "Type_Float" (string_of_type Type_Float); - check string "bool" "Type_Boolean" (string_of_type Type_Boolean); - check string "string" "Type_String" (string_of_type Type_String); - check string "char" "Type_Character" (string_of_type Type_Character); - check string "void" "Type_Void" (string_of_type Type_Void) + let tests = + [ + ("int", "IntegerType", IntegerType); + ("float", "FloatType", FloatType); + ("char", "CharacterType", CharacterType); + ("string", "StringType", StringType); + ("bool", "BooleanType", BooleanType); + ("void", "VoidType", VoidType); + ] + in + List.iter + (fun (name, expected, actual) -> + (check string) name expected (To_test._type actual)) + tests let test_string_of_literal () = - check string "42" "Integer(42)" (string_of_literal (Integer 42)); - check string "3.14" "Float(3.14)" (string_of_literal (Float 3.14)); - check string "true" "Boolean(true)" (string_of_literal (Boolean true)); - check string "false" "Boolean(false)" (string_of_literal (Boolean false)); - check string "hello" "String(\"hello\")" (string_of_literal (String "hello")); - check string "c" "Character('c')" (string_of_literal (Character 'c')); - check string "null" "Null" (string_of_literal Null) + let tests = + [ + ("42", "Integer(42)", Integer 42); + ("3.14", "Float(3.14)", Float 3.14); + ("true", "Boolean(true)", Boolean true); + ("false", "Boolean(false)", Boolean false); + ("hello", "String(\"hello\")", String "hello"); + ("c", "Character('c')", Character 'c'); + ("null", "Null", Null); + ] + in + List.iter + (fun (name, expected, actual) -> + (check string) name expected (To_test.literal actual)) + tests let test_string_of_binary_operator () = - check string "+" "Add" (string_of_binary_operator Add); - check string "-" "Substract" (string_of_binary_operator Substract); - check string "*" "Multiply" (string_of_binary_operator Multiply); - check string "/" "Divide" (string_of_binary_operator Divide); - check string "&&" "AmpersandAmpersand" - (string_of_binary_operator AmpersandAmpersand); - check string "||" "BarBar" (string_of_binary_operator BarBar); - check string "==" "EqualsEquals" (string_of_binary_operator EqualsEquals); - check string "!=" "ExclamationEquals" - (string_of_binary_operator ExclamationEquals); - check string "<" "LessThan" (string_of_binary_operator LessThan); - check string "<=" "LessThanEquals" (string_of_binary_operator LessThanEquals); - check string ">" "GreaterThan" (string_of_binary_operator GreaterThan); - check string ">=" "GreaterThanEquals" - (string_of_binary_operator GreaterThanEquals) + let tests = + [ + ("+", "Add", Add); + ("-", "Substract", Substract); + ("*", "Multiply", Multiply); + ("/", "Divide", Divide); + ("&&", "AmpersandAmpersand", AmpersandAmpersand); + ("||", "BarBar", BarBar); + ("==", "EqualsEquals", EqualsEquals); + ("!=", "ExclamationEquals", ExclamationEquals); + ("<", "LessThan", LessThan); + ("<=", "LessThanEquals", LessThanEquals); + (">", "GreaterThan", GreaterThan); + (">=", "GreaterThanEquals", GreaterThanEquals); + ] + in + List.iter + (fun (name, expected, actual) -> + (check string) name expected (To_test.binary_operator actual)) + tests let test_string_of_unary_operator () = - check string "-" "Negate" (string_of_unary_operator Negate); - check string "!" "Not" (string_of_unary_operator Not) + let tests = [ ("-", "Negate", Negate); ("!", "Not", Not) ] in + List.iter + (fun (name, expected, actual) -> + (check string) name expected (To_test.unary_operator actual)) + tests let test_string_of_expression () = - let expr = Literal (Integer 42) in - check string "42" "Literal(Integer(42))" (string_of_expression expr); - let expr = BinaryExpression (Add, Literal (Integer 1), Literal (Integer 2)) in - check string "1 + 2" - "BinaryExpression(Add, Literal(Integer(1)), Literal(Integer(2)))" - (string_of_expression expr); - let expr = UnaryExpression (Negate, Literal (Integer 42)) in - check string "-42" "UnaryExpression(Negate, Literal(Integer(42)))" - (string_of_expression expr); - let expr = Identifier "x" in - check string "x" "Identifier(\"x\")" (string_of_expression expr) + let tests = + [ + ("42", "Literal(Integer(42))", Literal (Integer 42)); + ( "1 + 2", + "BinaryExpression(Add, Literal(Integer(1)), Literal(Integer(2)))", + BinaryExpression (Add, Literal (Integer 1), Literal (Integer 2)) ); + ( "-42", + "UnaryExpression(Negate, Literal(Integer(42)))", + UnaryExpression (Negate, Literal (Integer 42)) ); + ("x", "Identifier(\"x\")", Identifier "x"); + ] + in + List.iter + (fun (name, expected, actual) -> + (check string) name expected (To_test.expression actual)) + tests let test_string_of_statement () = - let stmt = ExpressionStatement (Literal (Integer 42)) in - check string "42;" "ExpressionStatement(Literal(Integer(42)))" - (string_of_statement stmt); - let stmt = - VariableStatement - [ VariableDeclaration (Type_Integer, Identifier "x", Literal Null) ] + let tests = + [ + ( "42;", + "ExpressionStatement(Literal(Integer(42)))", + ExpressionStatement (Literal (Integer 42)) ); + ( "int x;", + "VariableStatement([VariableDeclaration(IntegerType, \ + Identifier(\"x\"), Literal(Null))])", + VariableStatement + [ VariableDeclaration (IntegerType, Identifier "x", Literal Null) ] ); + ( "int x = 42;", + "VariableStatement([VariableDeclaration(IntegerType, \ + Identifier(\"x\"), Literal(Integer(42)))])", + VariableStatement + [ + VariableDeclaration + (IntegerType, Identifier "x", Literal (Integer 42)); + ] ); + ] in - check string "int x;" - "VariableStatement([VariableDeclaration(Type_Integer, Identifier(\"x\"), \ - Literal(Null))])" - (string_of_statement stmt); - let stmt = - VariableStatement - [ - VariableDeclaration (Type_Integer, Identifier "x", Literal (Integer 42)); - ] - in - check string "int x = 42;" - "VariableStatement([VariableDeclaration(Type_Integer, Identifier(\"x\"), \ - Literal(Integer(42)))])" - (string_of_statement stmt) + List.iter + (fun (name, expected, actual) -> + (check string) name expected (To_test.statement actual)) + tests let test_string_of_source_file () = - let source_file = - SourceFile - [ - ExpressionStatement (Literal (Integer 1)); - ExpressionStatement - (BinaryExpression (Add, Literal (Integer 2), Literal (Integer 3))); - ] + let tests = + [ + ( "1; 2 + 3;", + "SourceFile([ExpressionStatement(Literal(Integer(1))), \ + ExpressionStatement(BinaryExpression(Add, Literal(Integer(2)), \ + Literal(Integer(3))))])", + SourceFile + [ + ExpressionStatement (Literal (Integer 1)); + ExpressionStatement + (BinaryExpression (Add, Literal (Integer 2), Literal (Integer 3))); + ] ); + ] in - check string "1; 2 + 3;" - "SourceFile([ExpressionStatement(Literal(Integer(1))), \ - ExpressionStatement(BinaryExpression(Add, Literal(Integer(2)), \ - Literal(Integer(3))))])" - (string_of_source_file source_file) + List.iter + (fun (name, expected, actual) -> + (check string) name expected (To_test.source_file actual)) + tests let () = - let open Alcotest in - run "AST tests" + run "ast.print" [ ("string_of_type", [ test_case "type" `Quick test_string_of_type ]); ( "string_of_literal", diff --git a/test/ressources/test.🥐 b/test/ressources/test.🥐 index 46ff5cc..e9bc629 100644 --- a/test/ressources/test.🥐 +++ b/test/ressources/test.🥐 @@ -11,16 +11,16 @@ SourceFile([ Add, BinaryExpression( Add, - Literal(Integer(4) + Literal(Integer(4)), + Literal(Integer(2)) ), - Literal(Integer(2)) - ), - BinaryExpression( - Multiply, - Literal(Integer(3)), - Literal(Integer(1)) - )) - )] - )] -) -*/ \ No newline at end of file + BinaryExpression( + Multiply, + Literal(Integer(3)), + Literal(Integer(1)) + ) + ) + ) + ]) +]) +*/