// dimensions must be equal to be compatible) and identical element types.
bool VerifyCompatibleShapesSameElementType(TypeRange lhs, TypeRange rhs) {
  if (lhs.size() != rhs.size() || lhs.size() != 1) return false;
  if (failed(mlir::verifyCompatibleShape(lhs[0], rhs[0]))) return false;
  auto lhsShaped = lhs[0].cast<ShapedType>();
  auto rhsShaped = rhs[0].cast<ShapedType>();
  return lhsShaped.getElementType() == rhsShaped.getElementType();

                                   Value lhs, Value rhs, Value output,
                                   StringAttr dot_dimension_numbers_str) {
  xla::DotDimensionNumbers dot_dimension_numbers;
  dot_dimension_numbers.ParseFromString(dot_dimension_numbers_str.str());
  SmallVector<Value> input_arguments = {lhs, rhs};
  const int lhs_rank = mlir::cast<ShapedType>(lhs.getType()).getShape().size();

        metadata.selectLegacyConfigurations(fromConfig, toComponent, resolutionFailureHandler).variants == [toConfig1, toConfig2]
    }

    def "configuration mapping can use wildcard on LHS"() {
        def resolutionFailureHandler = Stub(ResolutionFailureHandler)
        def toComponent = Stub(ComponentGraphResolveState)
        def fromConfig = Stub(ModuleConfigurationMetadata)

// MIN-MAX-CHECK-NEXT:  [[lhs:%.*]], {{.*}}, {{.*}}, {{.*}} = "tf.CustomAggregator"(%arg0) <{calibration_method = 1 : i32, id = "composite_conv2d_with_relu6_fn_arg_0_calibration_method_1", max_percentile = 0.000000e+00 : f32, min_percentile = 0.000000e+00 : f32, num_bins = 0 : i32}>...

     *
     * @param lhs the first object (can be {@code null})
     * @param rhs the second object (can be {@code null})
     * @return {@code true} if the objects are equal in the sense described above
     */
    private static boolean simpleOrRefEquals(@Nullable Object lhs, @Nullable Object rhs) {
        if (lhs == rhs) {
            return true;
        }

 *  We decide that the LHS is a type reference by checking if the left hand
 *  side is a (qualified) name, and, in case it _is_, resolving that name.
 *
 *  If it resolves to a non-class declaration, it does _not_ refer to a type.
 */
private fun doesDoubleColonUseLHS(lhs: PsiElement): Boolean {
    val reference = when (val inner = lhs.unwrapParenthesesLabelsAndAnnotations()) {

  static ResourceConstructingOps EntryState(Value value);
  bool operator==(const ResourceConstructingOps &rhs) const {
    return ops == rhs.ops;
  }

  static ResourceConstructingOps join(const ResourceConstructingOps &lhs,
                                      const ResourceConstructingOps &rhs);
  void print(raw_ostream &os) const;

  // The operation(s) which created the resource value.

    BatchMatMulOpType op, PatternRewriter& rewriter) const {
  Value input_lhs = op.getX();
  Value input_rhs = op.getY();

  if (!mlir::isa<RankedTensorType>(input_lhs.getType())) {
    // LHS must be a ranked tensor type
    return failure();
  }
  if (!mlir::isa<RankedTensorType>(input_rhs.getType())) {
    // RHS must be a ranked tensor type
    return failure();
  }

			if node.Op == token.SHL || node.Op == token.SHR {
				checkLongShift(pass, node, node.X, node.Y)
			}
		case *ast.AssignStmt:
			if len(node.Lhs) != 1 || len(node.Rhs) != 1 {
				return
			}
			if node.Tok == token.SHL_ASSIGN || node.Tok == token.SHR_ASSIGN {
				checkLongShift(pass, node, node.Lhs[0], node.Rhs[0])
			}
		}
	})
	return nil, nil
}

// checkLongShift checks if shift or shift-assign operations shift by more than

internal fun FirEqualityOperatorCall.processEqualsFunctions(
    session: FirSession,
    analysisSession: KaFirSession,
    processor: (FirNamedFunctionSymbol) -> Unit,
) {
    val lhs = arguments.firstOrNull() ?: return
    val scope = lhs.resolvedType.scope(
        useSiteSession = session,
        scopeSession = analysisSession.getScopeSessionFor(analysisSession.useSiteSession),