Split out the TYPE_CHECK implementation for resources

- The old version is harder to reason about,
  due to having different handling for resources.

  Opcache has to check for MAY_BE_RESOURCE when transforming opcodes,
  JITing operations, etc.
- Nikic suggested considering a separate opcode in phpGH-4906

Performance impact: no improvement/worsening,
unless hypothetically if is_resource and is_int calls were to alternate.

- I tried optimizations such as avoiding SAVE_OPLINE when possible in
  TYPE_CHECK. This somehow made performance worse
  (possibly due to larger code size).

Making this COLD might make more sense - I doubt a typical application would
be bottlenecked by is_resource.

E.g. this case was unaffected for `loopnotnull_isnull(0, 30000000);`

```php
function loopnotnull_isnull($a, $b) {
  $count = 0;
  for ($i = $a; $i < $b; $i++) {
      if (is_null($i)) {
          $count++;
      }
  }
  return $count;
}
```

**NOTE: opcache.file_cache should be cleared by developers after this
commit**

Author: TysonAndre

Zend/zend_compile.c

@@ -2078,6 +2078,7 @@ ZEND_API int zend_is_smart_branch(const zend_op *opline) /* {{{ */
 		case ZEND_ISSET_ISEMPTY_STATIC_PROP:
 		case ZEND_INSTANCEOF:
 		case ZEND_TYPE_CHECK:
+		case ZEND_IS_RESOURCE:
 		case ZEND_DEFINED:
 		case ZEND_IN_ARRAY:
 		case ZEND_ARRAY_KEY_EXISTS:
@@ -3409,6 +3410,20 @@ static int zend_compile_func_is_scalar(znode *result, zend_ast_list *args) /* {{
 	return SUCCESS;
 }
 
+int zend_compile_func_is_resource(znode *result, zend_ast_list *args) /* {{{ */
+{
+	znode arg_node;
+
+	if (args->children != 1) {
+		return FAILURE;
+	}
+
+	zend_compile_expr(&arg_node, args->child[0]);
+	zend_emit_op_tmp(result, ZEND_IS_RESOURCE, &arg_node, NULL);
+	return SUCCESS;
+}
+/* }}} */
+
 int zend_compile_func_cast(znode *result, zend_ast_list *args, uint32_t type) /* {{{ */
 {
 	znode arg_node;
@@ -3926,7 +3941,7 @@ int zend_try_compile_special_func(znode *result, zend_string *lcname, zend_ast_l
 	} else if (zend_string_equals_literal(lcname, "is_object")) {
 		return zend_compile_func_typecheck(result, args, IS_OBJECT);
 	} else if (zend_string_equals_literal(lcname, "is_resource")) {
-		return zend_compile_func_typecheck(result, args, IS_RESOURCE);
+		return zend_compile_func_is_resource(result, args);
 	} else if (zend_string_equals_literal(lcname, "is_scalar")) {
 		return zend_compile_func_is_scalar(result, args);
 	} else if (zend_string_equals_literal(lcname, "boolval")) {

Zend/zend_vm_def.h

@@ -7862,16 +7862,9 @@ ZEND_VM_HOT_NOCONST_HANDLER(123, ZEND_TYPE_CHECK, CONST|TMPVAR|CV, ANY, TYPE_MAS
 
 	value = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
 	if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
-ZEND_VM_C_LABEL(type_check_resource):
-		if (opline->extended_value != MAY_BE_RESOURCE
-		 || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
-			result = 1;
-		}
+		result = 1;
 	} else if ((OP1_TYPE & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
-		value = Z_REFVAL_P(value);
-		if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
-			ZEND_VM_C_GOTO(type_check_resource);
-		}
+		result = (opline->extended_value >> (uint32_t)Z_TYPE_P(Z_REFVAL_P(value))) & 1;
 	} else if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
 		result = ((1 << IS_NULL) & opline->extended_value) != 0;
 		SAVE_OPLINE();
@@ -7890,6 +7883,38 @@ ZEND_VM_C_LABEL(type_check_resource):
 	}
 }
 
+ZEND_VM_HOT_NOCONST_HANDLER(195, ZEND_IS_RESOURCE, CONST|TMPVAR|CV, ANY, TYPE_MASK)
+{
+	USE_OPLINE
+	zval *value;
+
+	value = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
+ZEND_VM_C_LABEL(type_check_resource):
+	if (EXPECTED(Z_TYPE_P(value) == IS_RESOURCE)) {
+		int result = EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)));
+		SAVE_OPLINE();
+		FREE_OP1();
+		ZEND_VM_SMART_BRANCH(result, 1);
+	} else if ((OP1_TYPE & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
+		value = Z_REFVAL_P(value);
+		if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
+			ZEND_VM_C_GOTO(type_check_resource);
+		}
+	} else if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
+		SAVE_OPLINE();
+		ZVAL_UNDEFINED_OP1();
+		if (UNEXPECTED(EG(exception))) {
+            /* I'm not sure why ZEND_TYPE_CHECK did this. */
+			ZVAL_UNDEF(EX_VAR(opline->result.var));
+			HANDLE_EXCEPTION();
+		}
+		ZEND_VM_SMART_BRANCH(0, 0);
+	}
+	SAVE_OPLINE();
+	FREE_OP1();
+	ZEND_VM_SMART_BRANCH(0, 1);
+}
+
 ZEND_VM_HOT_HANDLER(122, ZEND_DEFINED, CONST, ANY, CACHE_SLOT)
 {
 	USE_OPLINE