def map_type(typename, extension=False, return_type=False):
if extension:
return extension_map_type(typename, return_type)
typeclass = class_for_typename(typename, "&PyAny")
if typeclass in RUST_TYPE_MAP:
return RUST_TYPE_MAP[typeclass]
return typename
def visit_ClassDef(self, node):
extractor = DeclarationExtractor(JuliaTranspiler())
extractor.visit(node)
declarations = node.declarations = extractor.get_declarations()
node.class_assignments = extractor.class_assignments
ret = super().visit_ClassDef(node)
if ret is not None:
return ret
decorators = [get_id(d) for d in node.decorator_list]
decorators = [
class_for_typename(t, None, self._imported_names)
for t in decorators
]
for d in decorators:
if d in CLASS_DISPATCH_TABLE:
ret = CLASS_DISPATCH_TABLE[d](self, node)
if ret is not None:
return ret
fields = []
index = 0
for declaration, typename in declarations.items():
if typename == None:
typename = "ST{0}".format(index)
index += 1
fields.append(f"{declaration}::{typename}")
fields = "\n".join(fields)
struct_def = f"struct {node.name}\n{fields}\nend\n"
for b in node.body:
if isinstance(b, ast.FunctionDef):
b.self_type = node.name
body = "\n".join([self.visit(b) for b in node.body])
return f"{struct_def}\n{body}"
def visit_AnnAssign(self, node: ast.AnnAssign) -> ast.AST:
self.generic_visit(node)
node.target.annotation = node.annotation
target = node.target
target_typename = self._clike._typename_from_annotation(target)
if target_typename in self.FIXED_WIDTH_INTS_NAME:
self.has_fixed_width_ints = True
annotation = get_inferred_type(node.value)
value_typename = self._clike._generic_typename_from_type_node(
annotation)
target_class = class_for_typename(target_typename, None)
value_class = class_for_typename(value_typename, None)
if (not is_compatible(target_class, value_class, target, node.value)
and target_class != None):
raise AstIncompatibleAssign(
f"{target_class} incompatible with {value_class}", node)
return node
def _handle_overflow(self, op, left_id, right_id):
widening_op = isinstance(op, ast.Add) or isinstance(op, ast.Mult)
left_class = class_for_typename(left_id, None)
right_class = class_for_typename(right_id, None)
left_idx = (self.FIXED_WIDTH_INTS_LIST.index(left_class)
if left_class in self.FIXED_WIDTH_INTS else -1)
right_idx = (self.FIXED_WIDTH_INTS_LIST.index(right_class)
if right_class in self.FIXED_WIDTH_INTS else -1)
max_idx = max(left_idx, right_idx)
cint64_idx = self.FIXED_WIDTH_INTS_LIST.index(c_int64)
if widening_op:
if max_idx not in {
-1, cint64_idx,
len(self.FIXED_WIDTH_INTS_LIST) - 1
}:
# i8 + i8 => i16 for example
return self.FIXED_WIDTH_INTS_NAME_LIST[max_idx + 1]
if left_id == "float" or right_id == "float":
return "float"
return left_id if left_idx > right_idx else right_id
def visit_ClassDef(self, node):
extractor = DeclarationExtractor(CppTranspiler())
extractor.visit(node)
declarations = node.declarations = extractor.get_declarations()
node.class_assignments = extractor.class_assignments
ret = super().visit_ClassDef(node)
if ret is not None:
return ret
decorators = [get_id(d) for d in node.decorator_list]
decorators = [
class_for_typename(t, None, self._imported_names)
for t in decorators
]
for d in decorators:
if d in CLASS_DISPATCH_TABLE:
ret = CLASS_DISPATCH_TABLE[d](self, node)
if ret is not None:
return ret
buf = [f"class {node.name} {{"]
buf += ["public:"]
fields = []
index = 0
for declaration, typename in declarations.items():
if typename == None:
typename = "ST{0}".format(index)
index += 1
fields.append(f"{typename} {declaration}")
for b in node.body:
if isinstance(b, ast.FunctionDef):
b.self_type = node.name
buf += [";\n".join(fields + [""])]
body = [self.visit(b) for b in node.body]
if node.is_dataclass:
field_names = [arg for arg in declarations.keys()]
args = ", ".join(fields)
assignments = "; ".join(
[f"this->{field} = {field}" for field in field_names])
constructor = f"{node.name}({args}) {{{assignments};}}"
body = [constructor] + body
buf += body
buf += ["};"]
return "\n".join(buf) + "\n"
def visit_ClassDef(self, node) -> str:
extractor = DeclarationExtractor(RustTranspiler())
extractor.visit(node)
node.declarations = declarations = extractor.get_declarations()
node.declarations_with_defaults = extractor.get_declarations_with_defaults()
node.class_assignments = extractor.class_assignments
ret = super().visit_ClassDef(node)
if ret is not None:
return ret
decorators = [get_id(d) for d in node.decorator_list]
if "sealed" in decorators:
# TODO: handle cases where sealed is stacked with other decorators
return self.visit_sealed_class(node)
decorators = [
class_for_typename(t, None, self._imported_names) for t in decorators
]
for d in decorators:
if d in CLASS_DISPATCH_TABLE:
ret = CLASS_DISPATCH_TABLE[d](self, node)
if ret is not None:
return ret
fields = []
index = 0
for declaration, typename in declarations.items():
if typename == None:
typename = "ST{0}".format(index)
index += 1
fields.append(f"pub {declaration}: {typename},")
for b in node.body:
if isinstance(b, ast.FunctionDef):
b.self_type = node.name
extension = "#[pyclass]\n" if self.extension else ""
struct_def = "pub struct {0} {{\n{1}\n}}\n\n".format(
node.name, "\n".join(fields)
)
impl_extension = "#[pymethods]\n" if self.extension else ""
impl_def = f"{impl_extension}impl {node.name} {{\n"
buf = [self.visit(b) for b in node.body]
buf_str = "\n".join(buf)
return f"{extension}{struct_def}{impl_def}{buf_str} \n}}"
def visit_ClassDef(self, node):
extractor = DeclarationExtractor(DartTranspiler())
extractor.visit(node)
declarations = node.declarations = extractor.get_declarations()
node.class_assignments = extractor.class_assignments
ret = super().visit_ClassDef(node)
if ret is not None:
return ret
decorators = [get_id(d) for d in node.decorator_list]
decorators = [
class_for_typename(t, None, self._imported_names)
for t in decorators
]
for d in decorators:
if d in CLASS_DISPATCH_TABLE:
ret = CLASS_DISPATCH_TABLE[d](self, node)
if ret is not None:
return ret
fields = []
index = 0
constructor = ""
for declaration, typename in declarations.items():
if typename == None:
typename = "ST{0}".format(index)
index += 1
fields.append(f"{typename} {declaration};")
for b in node.body:
if isinstance(b, ast.FunctionDef):
b.self_type = node.name
fields = "\n".join(fields)
body = [self.visit(b) for b in node.body]
if node.is_dataclass:
args = [arg for arg in declarations.keys()]
args = ", ".join([f"this.{arg}" for arg in args])
constructor = f"{node.name}({args}) {{}}"
body = [constructor] + body
body = "\n".join(body)
return f"class {node.name} {{\n{fields}\n\n {body}\n}}\n"
def visit_ClassDef(self, node) -> str:
extractor = DeclarationExtractor(KotlinTranspiler())
extractor.visit(node)
declarations = node.declarations = extractor.get_declarations()
node.class_assignments = extractor.class_assignments
ret = super().visit_ClassDef(node)
if ret is not None:
return ret
decorators = [get_id(d) for d in node.decorator_list]
decorators = [
class_for_typename(t, None, self._imported_names)
for t in decorators
]
for d in decorators:
if d in CLASS_DISPATCH_TABLE:
ret = CLASS_DISPATCH_TABLE[d](self, node)
if ret is not None:
return ret
fields = []
index = 0
for declaration, typename in declarations.items():
if typename == None:
typename = "ST{0}".format(index)
index += 1
mut = is_mutable(node.scopes, get_id(declaration))
mut = "var" if mut else "val"
fields.append(f"{mut} {declaration}: {typename}")
for b in node.body:
if isinstance(b, ast.FunctionDef):
b.self_type = node.name
if node.is_dataclass:
fields = ", ".join(fields)
body = [self.visit(b) for b in node.body]
body = "\n".join(body)
return f"data class {node.name}({fields}) {{\n{body}\n}}\n"
else:
fields = "\n".join(fields)
body = [self.visit(b) for b in node.body]
body = "\n".join(body)
return f"class {node.name} {{\n{fields}\n\n {body}\n}}\n"
def visit_ClassDef(self, node) -> str:
extractor = DeclarationExtractor(NimTranspiler())
extractor.visit(node)
declarations = node.declarations = extractor.get_declarations()
node.class_assignments = extractor.class_assignments
ret = super().visit_ClassDef(node)
if ret is not None:
return ret
decorators = [get_id(d) for d in node.decorator_list]
decorators = [
class_for_typename(t, None, self._imported_names)
for t in decorators
]
for d in decorators:
if d in CLASS_DISPATCH_TABLE:
ret = CLASS_DISPATCH_TABLE[d](self, node)
if ret is not None:
return ret
fields = []
index = 0
for declaration, typename in declarations.items():
if typename == None:
typename = "ST{0}".format(index)
index += 1
fields.append(f"{declaration}: {typename}")
for b in node.body:
if isinstance(b, ast.FunctionDef):
b.self_type = node.name
object_def = "type\n"
object_def += self.indent(f"{node.name} = object\n",
level=node.level + 1)
object_def += "\n".join(
[self.indent(f, level=node.level + 2) for f in fields])
body = [self.visit(b) for b in node.body]
body = "\n".join(body)
return f"{object_def}\n{body}\n"
def extension_map_type(typename, return_type=False):
if typename == "_":
return "&PyAny"
if typename == None and return_type:
return "PyResult<()>"
typeclass = class_for_typename(typename, "&PyAny")
if typeclass in RUST_EXTENSION_TYPE_MAP:
if return_type and typeclass == str:
typename = "String"
return f"PyResult<{typename}>"
else:
return RUST_EXTENSION_TYPE_MAP[typeclass]
if typeclass in RUST_TYPE_MAP:
return RUST_TYPE_MAP[typeclass]
if return_type and typename not in InferRustTypesTransformer.FIXED_WIDTH_INTS_NAME:
return f"PyResult<{typename}>"
else:
return typename
def visit_ClassDef(self, node):
extractor = DeclarationExtractor(SmtTranspiler())
extractor.visit(node)
declarations = node.declarations = extractor.get_declarations()
node.declarations_with_defaults = extractor.get_declarations_with_defaults()
node.class_assignments = extractor.class_assignments
ret = super().visit_ClassDef(node)
if ret is not None:
return ret
decorators = [get_id(d) for d in node.decorator_list]
if "sealed" in decorators:
# TODO: handle cases where sealed is stacked with other decorators
return self.visit_sealed_class(node)
decorators = [
class_for_typename(t, None, self._imported_names) for t in decorators
]
for d in decorators:
if d in CLASS_DISPATCH_TABLE:
ret = CLASS_DISPATCH_TABLE[d](self, node)
if ret is not None:
return ret
fields = []
index = 0
for declaration, typename in declarations.items():
if typename == None:
typename = "ST{0}".format(index)
index += 1
fields.append(f"{declaration}: {typename}")
for b in node.body:
if isinstance(b, ast.FunctionDef):
b.self_type = node.name
return ""
def map_type(typename):
typeclass = class_for_typename(typename, None)
if typeclass in KT_TYPE_MAP:
return KT_TYPE_MAP[typeclass]
return typename
def map_type(typename: str) -> str:
typeclass = class_for_typename(typename, None)
return V_TYPE_MAP.get(typeclass, typename)
