def get_rhs(self, rhs: Expression, expected_type: AnnotatedTypeName):
if isinstance(rhs, TupleExpr):
if not isinstance(rhs, TupleExpr) or not isinstance(
expected_type.type_name, TupleType) or len(
rhs.elements) != len(expected_type.type_name.types):
raise TypeMismatchException(expected_type, rhs.annotated_type,
rhs)
exprs = [
self.get_rhs(a, e)
for e, a, in zip(expected_type.type_name.types, rhs.elements)
]
return replace_expr(rhs, TupleExpr(exprs)).as_type(
TupleType([e.annotated_type for e in exprs]))
instance = rhs.instanceof(expected_type)
if not instance:
raise TypeMismatchException(expected_type, rhs.annotated_type, rhs)
else:
if rhs.annotated_type.type_name != expected_type.type_name:
rhs = self.implicitly_converted_to(rhs,
expected_type.type_name)
if instance == 'make-private':
return self.make_private(rhs, expected_type.privacy_annotation)
else:
return rhs
def make_private_if_not_already(self, ast: Expression):
if ast.annotated_type.is_private():
expected = AnnotatedTypeName(ast.annotated_type.type_name,
Expression.me_expr())
if not ast.instanceof(expected):
raise TypeMismatchException(expected, ast.annotated_type, ast)
return ast
else:
return self.make_private(ast, Expression.me_expr())
def handle_cast(self, expr: Expression, t: TypeName) -> AnnotatedTypeName:
# because of the fake solidity check we already know that the cast is possible -> don't have to check if cast possible
if expr.annotated_type.is_private():
expected = AnnotatedTypeName(expr.annotated_type.type_name,
Expression.me_expr())
if not expr.instanceof(expected):
raise TypeMismatchException(expected, expr.annotated_type,
expr)
return AnnotatedTypeName(t.clone(), Expression.me_expr())
else:
return AnnotatedTypeName(t.clone())
