[mypyc] Cleanup old style primitive code (#9699)

We have moved all the existing ops into the new IR, so this PR removes the 
old PrimitiveOp and related code.

Relates to mypyc/mypyc#709, closes mypyc/mypyc#753

mypyc/analysis/dataflow.py

@@ -8,7 +8,7 @@
  Value, ControlOp,
  BasicBlock, OpVisitor, Assign, LoadInt, LoadErrorValue, RegisterOp, Goto, Branch, Return, Call,
  Environment, Box, Unbox, Cast, Op, Unreachable, TupleGet, TupleSet, GetAttr, SetAttr,
- LoadStatic, InitStatic, PrimitiveOp, MethodCall, RaiseStandardError, CallC, LoadGlobal,
+ LoadStatic, InitStatic, MethodCall, RaiseStandardError, CallC, LoadGlobal,
  Truncate, BinaryIntOp, LoadMem, GetElementPtr, LoadAddress, ComparisonOp, SetMem
 )
 
@@ -161,9 +161,6 @@ def visit_call(self, op: Call) -> GenAndKill:
  def visit_method_call(self, op: MethodCall) -> GenAndKill:
  return self.visit_register_op(op)
 
- def visit_primitive_op(self, op: PrimitiveOp) -> GenAndKill:
- return self.visit_register_op(op)
-
  def visit_load_int(self, op: LoadInt) -> GenAndKill:
  return self.visit_register_op(op)
 

mypyc/codegen/emitfunc.py

@@ -10,7 +10,7 @@
 from mypyc.ir.ops import (
  OpVisitor, Goto, Branch, Return, Assign, LoadInt, LoadErrorValue, GetAttr, SetAttr,
  LoadStatic, InitStatic, TupleGet, TupleSet, Call, IncRef, DecRef, Box, Cast, Unbox,
- BasicBlock, Value, MethodCall, PrimitiveOp, EmitterInterface, Unreachable, NAMESPACE_STATIC,
+ BasicBlock, Value, MethodCall, EmitterInterface, Unreachable, NAMESPACE_STATIC,
  NAMESPACE_TYPE, NAMESPACE_MODULE, RaiseStandardError, CallC, LoadGlobal, Truncate,
  BinaryIntOp, LoadMem, GetElementPtr, LoadAddress, ComparisonOp, SetMem, Register
 )
@@ -152,17 +152,6 @@ def visit_return(self, op: Return) -> None:
  regstr = self.reg(op.reg)
  self.emit_line('return %s;' % regstr)
 
- def visit_primitive_op(self, op: PrimitiveOp) -> None:
- args = [self.reg(arg) for arg in op.args]
- if not op.is_void:
- dest = self.reg(op)
- else:
- # This will generate a C compile error if used. The reason for this
- # is that we don't want to insert "assert dest is not None" checks
- # everywhere.
- dest = '<undefined dest>'
- op.desc.emit(self, args, dest)
-
  def visit_tuple_set(self, op: TupleSet) -> None:
  dest = self.reg(op)
  tuple_type = op.tuple_type

mypyc/ir/ops.py

@@ -12,7 +12,7 @@
 
 from abc import abstractmethod
 from typing import (
- List, Sequence, Dict, Generic, TypeVar, Optional, Any, NamedTuple, Tuple, Callable,
+ List, Sequence, Dict, Generic, TypeVar, Optional, Any, NamedTuple, Tuple,
  Union, Iterable, Set
 )
 from mypy.ordered_dict import OrderedDict
@@ -693,84 +693,9 @@ def emit_declaration(self, line: str) -> None:
  raise NotImplementedError
 
 
-EmitCallback = Callable[[EmitterInterface, List[str], str], None]
-
 # True steals all arguments, False steals none, a list steals those in matching positions
 StealsDescription = Union[bool, List[bool]]
 
-# Description of a primitive operation
-OpDescription = NamedTuple(
- 'OpDescription', [('name', str),
- ('arg_types', List[RType]),
- ('result_type', Optional[RType]),
- ('is_var_arg', bool),
- ('error_kind', int),
- ('format_str', str),
- ('emit', EmitCallback),
- ('steals', StealsDescription),
- ('is_borrowed', bool),
- ('priority', int)]) # To resolve ambiguities, highest priority wins
-
-
-class PrimitiveOp(RegisterOp):
- """reg = op(reg, ...)
-
- These are register-based primitive operations that work on specific
- operand types.
-
- The details of the operation are defined by the 'desc'
- attribute. The modules under mypyc.primitives define the supported
- operations. mypyc.irbuild uses the descriptions to look for suitable
- primitive ops.
- """
-
- def __init__(self,
- args: List[Value],
- desc: OpDescription,
- line: int) -> None:
- if not desc.is_var_arg:
- assert len(args) == len(desc.arg_types)
- self.error_kind = desc.error_kind
- super().__init__(line)
- self.args = args
- self.desc = desc
- if desc.result_type is None:
- assert desc.error_kind == ERR_FALSE # TODO: No-value ops not supported yet
- self.type = bool_rprimitive
- else:
- self.type = desc.result_type
-
- self.is_borrowed = desc.is_borrowed
-
- def sources(self) -> List[Value]:
- return list(self.args)
-
- def stolen(self) -> List[Value]:
- if isinstance(self.desc.steals, list):
- assert len(self.desc.steals) == len(self.args)
- return [arg for arg, steal in zip(self.args, self.desc.steals) if steal]
- else:
- return [] if not self.desc.steals else self.sources()
-
- def __repr__(self) -> str:
- return '<PrimitiveOp name=%r args=%s>' % (self.desc.name,
- self.args)
-
- def to_str(self, env: Environment) -> str:
- params = {} # type: Dict[str, Any]
- if not self.is_void:
- params['dest'] = env.format('%r', self)
- args = [env.format('%r', arg) for arg in self.args]
- params['args'] = args
- params['comma_args'] = ', '.join(args)
- params['colon_args'] = ', '.join(
- '{}: {}'.format(k, v) for k, v in zip(args[::2], args[1::2])
- )
- return self.desc.format_str.format(**params).strip()
-
- def accept(self, visitor: 'OpVisitor[T]') -> T:
- return visitor.visit_primitive_op(self)
-
 
 class Assign(Op):
  """Assign a value to a register (dest = int)."""
@@ -1555,10 +1480,6 @@ def visit_return(self, op: Return) -> T:
  def visit_unreachable(self, op: Unreachable) -> T:
  raise NotImplementedError
 
- @abstractmethod
- def visit_primitive_op(self, op: PrimitiveOp) -> T:
- raise NotImplementedError
-
  @abstractmethod
  def visit_assign(self, op: Assign) -> T:
  raise NotImplementedError

mypyc/irbuild/builder.py

@@ -34,7 +34,7 @@
  BasicBlock, AssignmentTarget, AssignmentTargetRegister, AssignmentTargetIndex,
  AssignmentTargetAttr, AssignmentTargetTuple, Environment, LoadInt, Value,
  Register, Op, Assign, Branch, Unreachable, TupleGet, GetAttr, SetAttr, LoadStatic,
- InitStatic, OpDescription, NAMESPACE_MODULE, RaiseStandardError,
+ InitStatic, NAMESPACE_MODULE, RaiseStandardError,
 )
 from mypyc.ir.rtypes import (
  RType, RTuple, RInstance, int_rprimitive, dict_rprimitive,
@@ -43,7 +43,7 @@
 )
 from mypyc.ir.func_ir import FuncIR, INVALID_FUNC_DEF
 from mypyc.ir.class_ir import ClassIR, NonExtClassInfo
-from mypyc.primitives.registry import func_ops, CFunctionDescription, c_function_ops
+from mypyc.primitives.registry import CFunctionDescription, c_function_ops
 from mypyc.primitives.list_ops import to_list, list_pop_last
 from mypyc.primitives.dict_ops import dict_get_item_op, dict_set_item_op
 from mypyc.primitives.generic_ops import py_setattr_op, iter_op, next_op
@@ -188,9 +188,6 @@ def load_static_unicode(self, value: str) -> Value:
  def load_static_int(self, value: int) -> Value:
  return self.builder.load_static_int(value)
 
- def primitive_op(self, desc: OpDescription, args: List[Value], line: int) -> Value:
- return self.builder.primitive_op(desc, args, line)
-
  def unary_op(self, lreg: Value, expr_op: str, line: int) -> Value:
  return self.builder.unary_op(lreg, expr_op, line)
 
@@ -763,12 +760,6 @@ def call_refexpr_with_args(
  expr.line, self.node_type(expr))
  if target:
  return target
- ops = func_ops.get(callee.fullname, [])
- target = self.builder.matching_primitive_op(
- ops, arg_values, expr.line, self.node_type(expr)
- )
- if target:
- return target
 
  # Standard native call if signature and fullname are good and all arguments are positional
  # or named.

mypyc/irbuild/ll_builder.py

@@ -19,7 +19,7 @@
 from mypyc.ir.ops import (
  BasicBlock, Environment, Op, LoadInt, Value, Register,
  Assign, Branch, Goto, Call, Box, Unbox, Cast, GetAttr,
- LoadStatic, MethodCall, PrimitiveOp, OpDescription, RegisterOp, CallC, Truncate,
+ LoadStatic, MethodCall, RegisterOp, CallC, Truncate,
  RaiseStandardError, Unreachable, LoadErrorValue, LoadGlobal,
  NAMESPACE_TYPE, NAMESPACE_MODULE, NAMESPACE_STATIC, BinaryIntOp, GetElementPtr,
  LoadMem, ComparisonOp, LoadAddress, TupleGet, SetMem, ERR_NEVER, ERR_FALSE
@@ -39,7 +39,7 @@
  STATIC_PREFIX, PLATFORM_SIZE
 )
 from mypyc.primitives.registry import (
- func_ops, c_method_call_ops, CFunctionDescription, c_function_ops,
+ c_method_call_ops, CFunctionDescription, c_function_ops,
  c_binary_ops, c_unary_ops, ERR_NEG_INT
 )
 from mypyc.primitives.list_ops import (
@@ -513,48 +513,6 @@ def load_native_type_object(self, fullname: str) -> Value:
  return self.add(LoadStatic(object_rprimitive, name, module, NAMESPACE_TYPE))
 
  # Other primitive operations
-
- def primitive_op(self, desc: OpDescription, args: List[Value], line: int) -> Value:
- assert desc.result_type is not None
- coerced = []
- for i, arg in enumerate(args):
- formal_type = self.op_arg_type(desc, i)
- arg = self.coerce(arg, formal_type, line)
- coerced.append(arg)
- target = self.add(PrimitiveOp(coerced, desc, line))
- return target
-
- def matching_primitive_op(self,
- candidates: List[OpDescription],
- args: List[Value],
- line: int,
- result_type: Optional[RType] = None) -> Optional[Value]:
- # Find the highest-priority primitive op that matches.
- matching = None # type: Optional[OpDescription]
- for desc in candidates:
- if len(desc.arg_types) != len(args):
- continue
- if all(is_subtype(actual.type, formal)
- for actual, formal in zip(args, desc.arg_types)):
- if matching:
- assert matching.priority != desc.priority, 'Ambiguous:\n1) %s\n2) %s' % (
- matching, desc)
- if desc.priority > matching.priority:
- matching = desc
- else:
- matching = desc
- if matching:
- target = self.primitive_op(matching, args, line)
- if result_type and not is_runtime_subtype(target.type, result_type):
- if is_none_rprimitive(result_type):
- # Special case None return. The actual result may actually be a bool
- # and so we can't just coerce it.
- target = self.none()
- else:
- target = self.coerce(target, result_type, line)
- return target
- return None
-
  def binary_op(self,
  lreg: Value,
  rreg: Value,
@@ -857,10 +815,6 @@ def builtin_call(self,
  line: int) -> Value:
  call_c_ops_candidates = c_function_ops.get(fn_op, [])
  target = self.matching_call_c(call_c_ops_candidates, args, line)
- if target:
- return target
- ops = func_ops.get(fn_op, [])
- target = self.matching_primitive_op(ops, args, line)
  assert target, 'Unsupported builtin function: %s' % fn_op
  return target
 
@@ -1113,12 +1067,6 @@ def decompose_union_helper(self,
  self.activate_block(exit_block)
  return result
 
- def op_arg_type(self, desc: OpDescription, n: int) -> RType:
- if n >= len(desc.arg_types):
- assert desc.is_var_arg
- return desc.arg_types[-1]
- return desc.arg_types[n]
-
  def translate_special_method_call(self,
  base_reg: Value,
  name: str,

mypyc/primitives/list_ops.py

@@ -1,8 +1,6 @@
 """List primitive ops."""
 
-from typing import List
-
-from mypyc.ir.ops import ERR_MAGIC, ERR_NEVER, ERR_FALSE, EmitterInterface
+from mypyc.ir.ops import ERR_MAGIC, ERR_NEVER, ERR_FALSE
 from mypyc.ir.rtypes import (
  int_rprimitive, short_int_rprimitive, list_rprimitive, object_rprimitive, c_int_rprimitive,
  c_pyssize_t_rprimitive, bit_rprimitive
@@ -122,14 +120,6 @@
  c_function_name='CPySequence_RMultiply',
  error_kind=ERR_MAGIC)
 
-
-def emit_len(emitter: EmitterInterface, args: List[str], dest: str) -> None:
- temp = emitter.temp_name()
- emitter.emit_declaration('Py_ssize_t %s;' % temp)
- emitter.emit_line('%s = PyList_GET_SIZE(%s);' % (temp, args[0]))
- emitter.emit_line('%s = CPyTagged_ShortFromSsize_t(%s);' % (dest, temp))
-
-
 # list[begin:end]
 list_slice_op = c_custom_op(
  arg_types=[list_rprimitive, int_rprimitive, int_rprimitive],