// easier to write, but generates horrible messages when there is a
// compiler error, as gcc insists on printing out each template
// argument, even if it has the default value (this means Types<int>
// will appear as Types<int, None, None, ..., None> in the compiler
// errors).
//
// Our solution is to combine the best part of the two approaches: a

}

func TestGCBits(t *testing.T) {
	verifyGCBits(t, TypeOf((*byte)(nil)), []byte{1})

	// Building blocks for types seen by the compiler (like [2]Xscalar).
	// The compiler will create the type structures for the derived types,
	// including their GC metadata.
	type Xscalar struct{ x uintptr }
	type Xptr struct{ x *byte }
	type Xptrscalar struct {
		*byte

      %compile:2 = "tf._TPUCompileMlir"(...)
      %get_layout = "tf.TPUGetLayoutOp"(%compile#1) {...}
      %copy_to_device = "tf.TPUCopyWithLayout"(%input, %get_layout)
          {device = "/TPU:0"}
      %execute = "tf.TPUExecute"(%copy_to_device, ..., %compile#1)
          {device = "/TPU:0"}
    ```

    This way, %compile will determine the layout, which will be respected by

            }
            configurations {
                compile1 {
                    attributes { attribute usage, 'api' }
                }
                compile2 {
                    attributes { attribute usage, 'api' }
                }
            }
            dependencies {
                compile1 'test:test2:2.3'
                compile2 'test:test3:3.4'
            }

		cpu.DebugOptions = true
	}
	cpu.Initialize(env)

	// Support cpu feature variables are used in code generated by the compiler
	// to guard execution of instructions that can not be assumed to be always supported.
	switch GOARCH {
	case "386", "amd64":
		x86HasPOPCNT = cpu.X86.HasPOPCNT
		x86HasSSE41 = cpu.X86.HasSSE41

		reAssemble := false
		for i := range s.R[nrelocs0:] {
			s.R[nrelocs0+i] = obj.Reloc{}
		}
		s.R = s.R[:nrelocs0] // preserve marker relocations generated by the compiler
		s.P = s.P[:0]
		c = 0
		var pPrev *obj.Prog
		nops = nops[:0]
		for p := s.Func().Text; p != nil; p = p.Link {
			c0 := c
			c = pjc.padJump(ctxt, s, p, c)

					sb.SetType(sym.SDYNIMPORT)
				} else if strings.HasPrefix(ldr.SymName(rs), "go:info.") {
					// Skip go.info symbols. They are only needed to communicate
					// DWARF info between the compiler and linker.
					continue
				}
			} else if target.IsPPC64() && ldr.SymName(rs) == ".TOC." {
				// TOC symbol doesn't have a type but we do assign a value
				// (see the address pass) and we can resolve it.

                    artifacts {
                        compile rootProject.file("project-artifact.jar")
                    }
                }
                project(':app') {
                    dependencies {
                        compile project(':lib-project:producer')
                        compile 'com.test:producer:1.0'
                    }
                }
            """

    }

    func.return %1 : tensor<2xi32>
  }

  //  Tests the case when an outside compiled op with some dynamically shaped input but static output
  //  comes before an outside compiled op with some dynamically shaped input/output.  This ensures that
  //  for the second outside compiled op, all of the inputs are explicitly provided.

  // CHECK-LABEL: func @static_output_dynamic_input_outside_compilation

  }

  @Test
  public void testAllFilesPresentInSingleByPsi() {
    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/resolver/singleByPsi"), Pattern.compile("^(.+)\\.kt$"), null, true);
  }

  @Test
  @TestMetadata("annotationEntry.kt")
  public void testAnnotationEntry() {
    runTest("analysis/analysis-api/testData/components/resolver/singleByPsi/annotationEntry.kt");