def result(element):
lhs_type = element.env.canonicalize_name(type_string(element[0]))
rhs_type = element.env.canonicalize_name(type_string(element[2]))
if is_integral_primitive(lhs_type) and is_integral_primitive(rhs_type):
element.attrib["type"] = "int"
return
error_if(lhs_type != rhs_type != expected_type_string,
"binary_expression type mismatch")
element.attrib["type"] = expected_type_string
def relational_expression(element):
lhs_type = element.env.canonicalize_name(element[0].attrib['type'])
rhs_type = element.env.canonicalize_name(element[2].attrib['type'])
if element[1].text in ["<", ">", "<=", ">="]:
error_if(not (is_integral_primitive(lhs_type) and
is_integral_primitive(rhs_type)),
"Relational expression passed non-integral types.")
elif element[1].text == "instanceof":
error_if(is_primitive(lhs_type) or is_primitive(rhs_type),
"Cannot have primitives in instanceof")
element.attrib["type"] = "boolean"
def is_primitive_assignable(self, lhs, rhs):
if is_integral_primitive(lhs) and is_integral_primitive(rhs):
if lhs == "byte" and rhs in ["char", "int", "short"]:
return False
if lhs == "short" and (rhs == "int" or rhs == "char"):
return False
if lhs == "char" and (rhs == "byte" or rhs == "int"):
return False
return True
if lhs == rhs:
return True
return False
def are_identity_comparable(self, obj1, obj2):
"""Returns whether obj1 and obj2 can occur in an == expression."""
if obj1 == "null" or obj2 in ["null", "void", "void"]:
return True
if is_integral_primitive(obj1) ^ is_integral_primitive(obj2):
return False
if is_integral_primitive(obj1) and is_integral_primitive(obj2):
return True
if is_primitive(obj1) and obj1 == obj2:
return True
if self.is_subtype(obj1, obj2) or self.is_subtype(obj2, obj1):
return True
return False
def array_creation_expression(element):
base_name = collect_token_text(element[1])
if element.find(".//dim_expr") is not None:
base_name += "[]"
if element.find(".//dim_expr/expression") is not None:
type_str = element.find(".//dim_expr/expression").attrib["type"]
error_if(not is_integral_primitive(type_str),
"dim_expr require integral type")
element.attrib["type"] = element.env.canonicalize_name(base_name)
def unary_expression(element):
if len(element) == 2:
# Unary minus.
if element[0].tag == "tok_minus":
error_if(not is_integral_primitive(element[1].attrib["type"]),
"must negate integral primitive")
element.attrib["type"] = element[1].attrib["type"]
if element[0].tag == "tok_complement":
error_if(element[1].attrib["type"] != "boolean", "must !boolean")
element.attrib["type"] = element[1].attrib["type"]
def array_access(element):
if element[0].tag == "name":
name = name_to_str(element[0])
decl_site = element.env.get_declaration_site_for_variable_name(name,
element[0])
type_name = element.env.get_type_for_declaration_site(decl_site)
element.declaration = decl_site
else:
type_name = element[0].attrib["type"]
error_if(not isarray(type_name), "Array access on non-array type.")
element.attrib["type"] = type_name[:-2]
index_expression_type = element[-2].attrib["type"]
error_if(not is_integral_primitive(index_expression_type),
"Cannot index into array with non-integral expression.")