Code cleanup and minor additions to notebook

Andrew · Andrew · commit be675afd7092 · 2020-12-14T13:54:15.000-08:00
diff --git a/.gitignore b/.gitignore
@@ -133,3 +133,4 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+output/main.cpp
diff --git a/PyPlus Documentation.ipynb b/PyPlus Documentation.ipynb
@@ -37,7 +37,10 @@
     "These classes (classes prepended with cpp) hold definitions for object representations of C++ files, functions, variables, and code lines. This helps keep converted code organized and makes code export much easier.\n",
     "\n",
     "#### modules/pyplusexceptions\n",
-    "This class holds exceptions specific to pyplus. This is to help make exiting a recursive function call easier when code translation for a certain line isn't supported."
+    "This class holds exceptions specific to pyplus. This is to help make exiting a recursive function call easier when code translation for a certain line isn't supported.\n",
+    "\n",
+    "### Note on Code Style\n",
+    "PEP8 recommends using snake case for function names, however for several of my functions beginning with 'parse_', the following word is capitalized. This was a design decision, not an oversight. To help reduce the amount of code needed to call the appropriate functions to parse various nodes, the node's class name was used as part of the function name. This allows me to use getattr to find the correct function based on the name. As I am using the class name to find the correct function, this results in the capital letters in the function declarations."
    ]
   },
   {
diff --git a/modules/pyanalyzer.py b/modules/pyanalyzer.py
@@ -356,9 +356,10 @@ def find_else_lineno(self, search_index):
 
         Returns
         -------
-        tuple : (int, int)
-            Tuple containing the line number of the else statement and the
-            index of the last character of the else in the original python code
+        search_index : int
+            Line number of the else statement
+        end_col_offset : int
+            Index of the last character of the else in the original python code
 
         Raises
         ------
@@ -378,7 +379,8 @@ def find_else_lineno(self, search_index):
                     end_col_offset += 4
 
                 # Line number is 1+index in list
-                return search_index + 1, end_col_offset
+                search_index += 1
+                return search_index, end_col_offset
 
     def parse_While(self, node, file_index, function_key, indent):
         """
@@ -700,9 +702,10 @@ def parse_Call(self, node, file_index, function_key):
 
         Returns
         -------
-        tuple : (str, [str])
-            Tuple with the string representation of the call and the return
-            type in a list of a string
+        return_str : str
+            The call represented as a string
+        return_type : list of str
+            The return type of the call
 
         Raises
         ------
@@ -791,9 +794,10 @@ def parse_ported_function(self, file_index, function_key, function, args,
 
         Returns
         -------
-        tuple : (str, [str])
-            Tuple with the string representation of the ported function and the
-            return type in a list of a string
+        return_str : str
+            The ported function represented as a string
+        return_type : list of str
+            The return type of the ported function
 
         Raises
         ------
@@ -829,21 +833,27 @@ def parse_Constant(self, node, file_index, function_key):
 
         Returns
         -------
-        tuple : (str, [str])
-            Tuple with the string representation of the constant and the return
-            type in a list of a string
+        return_str : str
+            The constant value represented as a string
+        return_type : list of str
+            The type of the constant
         """
         # Strings need to be wrapped in quotes
         if type(node.value) is str:
-            return ("\"" + node.value + "\""), ["str"]
+            return_str = ("\"" + node.value + "\"")
+            return_type = ["str"]
 
         # Python booleans are capital while C++ is lowercase, so we need to
         # translate it
         elif type(node.value) is bool:
-            return cvar.CPPVariable.bool_map[str(node.value)], ["bool"]
+            return_str = cvar.CPPVariable.bool_map[str(node.value)]
+            return_type = ["bool"]
 
         else:
-            return str(node.value), [type(node.value).__name__]
+            return_str = str(node.value)
+            return_type = [type(node.value).__name__]
+
+        return return_str, return_type
 
     # Operators
     def parse_BoolOp(self, node, file_index, function_key):
@@ -861,9 +871,10 @@ def parse_BoolOp(self, node, file_index, function_key):
 
         Returns
         -------
-        tuple : (str, [str])
-            Tuple with the string representation of the BoolOp and the return
-            type in a list of a string
+        return_str : str
+            The BoolOp represented as a string
+        return_type : list of str
+            The return type of the BoolOp
 
         Raises
         ------
@@ -906,7 +917,8 @@ def parse_BoolOp(self, node, file_index, function_key):
         else:
             return_type = compare_nodes[0][1]
 
-        return "(" + return_str + ")", return_type
+        return_str = "(" + return_str + ")"
+        return return_str, return_type
 
     def parse_BinOp(self, node, file_index, function_key):
         """
@@ -923,9 +935,10 @@ def parse_BinOp(self, node, file_index, function_key):
 
         Returns
         -------
-        tuple : (str, [str])
-            Tuple with the string representation of the BinOp and the return
-            type in a list of a string
+        return_str : str
+            The BinOp represented as a string
+        return_type : list of str
+            The return type of the BinOp
 
         Raises
         ------
@@ -945,32 +958,33 @@ def parse_BinOp(self, node, file_index, function_key):
         if operator in PyAnalyzer.operator_map:
             if operator == "Pow":
                 self.output_files[file_index].add_include_file("math.h")
-                return_expr = "pow(" + left_str + ", " + right_str + ")"
+                return_str = "pow(" + left_str + ", " + right_str + ")"
                 return_type = ["float"]
 
             elif operator == "FloorDiv":
-                return_expr = left_str + " / " + right_str
+                return_str = left_str + " / " + right_str
                 # If they aren't both ints, we need to cast to int to truncate
                 if left_type[0] != "int" or right_type[0] != "int":
-                    return_expr = "(int)(" + return_expr + ")"
+                    return_str = "(int)(" + return_str + ")"
                 return_type = ["int"]
 
             elif operator == "Div":
-                return_expr = left_str + " / " + right_str
+                return_str = left_str + " / " + right_str
                 # We need to cast one to a double or it will perform integer
                 # math
                 if left_type[0] != "float" or right_type[0] != "float":
-                    return_expr = "(double)" + return_expr
+                    return_str = "(double)" + return_str
                 return_type = ["float"]
 
             else:
-                return_expr = left_str \
+                return_str = left_str \
                               + PyAnalyzer.operator_map[operator] \
                               + right_str
 
                 return_type = self.type_precedence(left_type, right_type)
 
-        return "(" + return_expr + ")", return_type
+        return_str = "(" + return_str + ")"
+        return return_str, return_type
 
     def type_precedence(self, type_a, type_b):
         """
@@ -987,7 +1001,7 @@ def type_precedence(self, type_a, type_b):
 
         Returns
         -------
-        list of str
+        return_type : list of str
             The list that holds the type that should take precedence
         """
         if type_a[0] in PyAnalyzer.type_precedence_dict and type_b[0] in PyAnalyzer.type_precedence_dict:
@@ -1020,9 +1034,10 @@ def parse_UnaryOp(self, node, file_index, function_key):
 
         Returns
         -------
-        tuple : (str, [str])
-            Tuple with the string representation of the UnaryOp and the return
-            type in a list of a string
+        return_str : str
+            The UnaryOp represented as a string
+        return_type : list of str
+            The return type of the UnaryOp
 
         Raises
         ------
@@ -1039,11 +1054,12 @@ def parse_UnaryOp(self, node, file_index, function_key):
 
         # Not operation becomes a bool no matter what type it operated on
         if operator is ast.Not:
-            return_type = "bool"
+            return_type = ["bool"]
         else:
-            return_type = "int"
+            return_type = ["int"]
 
-        return "(" + PyAnalyzer.operator_map[operator.__name__] + return_str + ")", [return_type]
+        return_str = "(" + PyAnalyzer.operator_map[operator.__name__] + return_str + ")"
+        return return_str, return_type
 
     def parse_Compare(self, node, file_index, function_key):
         """
@@ -1060,9 +1076,10 @@ def parse_Compare(self, node, file_index, function_key):
 
         Returns
         -------
-        tuple : (str, [str])
-            Tuple with the string representation of the comparison and the
-            return type in a list of a string
+        return_str : str
+            The Compare operation represented as a string
+        return_type : list of str
+            The return type of the Compare operation
 
         Raises
         ------
@@ -1101,7 +1118,9 @@ def parse_Compare(self, node, file_index, function_key):
                       PyAnalyzer.comparison_map[node.ops[-1].__class__.__name__] \
                       + comparator + ")"
 
-        return return_str, ["bool"]
+        # All comparisons come back as a bool
+        return_type = ["bool"]
+        return return_str, return_type
 
     def recurse_operator(self, node, file_index, function_key):
         """

Original file line number	Diff line number	Diff line change
`@@ -133,3 +133,4 @@ dmypy.json`
`133`	`133`
`134`	`134`	`# Pyre type checker`
`135`	`135`	`.pyre/`
	`136`	`+output/main.cpp`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,10 @@`
`37`	`37`	`"These classes (classes prepended with cpp) hold definitions for object representations of C++ files, functions, variables, and code lines. This helps keep converted code organized and makes code export much easier.\n",`
`38`	`38`	`"\n",`
`39`	`39`	`"#### modules/pyplusexceptions\n",`
`40`		`- "This class holds exceptions specific to pyplus. This is to help make exiting a recursive function call easier when code translation for a certain line isn't supported."`
	`40`	`+ "This class holds exceptions specific to pyplus. This is to help make exiting a recursive function call easier when code translation for a certain line isn't supported.\n",`
	`41`	`+ "\n",`
	`42`	`+ "### Note on Code Style\n",`
	`43`	+ "PEP8 recommends using snake case for function names, however for several of my functions beginning with 'parse_', the following word is capitalized. This was a design decision, not an oversight. To help reduce the amount of code needed to call the appropriate functions to parse various nodes, the node's class name was used as part of the function name. This allows me to use getattr to find the correct function based on the name. As I am using the class name to find the correct function, this results in the capital letters in the function declarations."
`41`	`44`	`]`
`42`	`45`	`},`
`43`	`46`	`{`