// CHECK-DAG: %[[Q1:.*]] = stablehlo.uniform_quantize %[[ARG0]]
  // CHECK-NOT: "quantfork.qcast"
  // CHECK: %[[DOT:.*]] = stablehlo.dot %[[Q1]], %[[QCST]]
  // CHECK: %[[DQ:.*]] = stablehlo.uniform_dequantize %[[DOT]]
  // CHECK: return %[[DQ]]
  %cst = stablehlo.constant dense<-0.390246302> : tensor<3x2xf32>

// DISABLE-ALL-DOT-GENERAL-SAME: _entry_function = @composite_dot_general_fn_1
// DISABLE-ALL-DOT-GENERAL-SAME: _original_entry_function
// DISABLE-ALL-DOT-GENERAL-SAME: _quantization_method = "no_quantization { }"
// DISABLE-ALL-DOT-GENERAL-SAME: _tfl_quant_trait = "fully_quantizable"

// DISABLE-ALL-DOT-GENERAL: return %[[XLA_CALL_MODULE:.+]] : tensor<1x1x64xf32>
// DISABLE-ALL-DOT-GENERAL: }

# Test that an import path containing an element with a leading dot
# in another module is valid.

# 'go get' works with no version query.
cp go.mod.empty go.mod
go get example.com/dotname/.dot
go list -m example.com/dotname
stdout '^example.com/dotname v1.0.0$'

# 'go get' works with a version query.
cp go.mod.empty go.mod
go get example.com/dotname/.dot@latest
go list -m example.com/dotname
stdout '^example.com/dotname v1.0.0$'

			Prefix:      false,
			ExpectedMsg: "",
		},

		"dot": {
			Name:        ".",
			Prefix:      false,
			ExpectedMsg: ".",
		},
		"dot leading": {
			Name:        ".test",
			Prefix:      false,
			ExpectedMsg: "",
		},
		"dot,prefix": {
			Name:        ".",
			Prefix:      true,
			ExpectedMsg: "",
		},

		"dot dot": {
			Name:        "..",
			Prefix:      false,
			ExpectedMsg: "..",

func.func @testDotToDotGeneralVectorVector(%arg0: tensor<3072xf32>, %arg1: tensor<3072xf32>) -> tensor<f32> {
  %0 = "mhlo.dot"(%arg0, %arg1) : (tensor<3072xf32>, tensor<3072xf32>) -> tensor<f32>
  func.return %0 : tensor<f32>

// CHECK:      %[[RES:.*]] = "mhlo.dot_general"(%arg0, %arg1) <{
// CHECK-SAME:   dot_dimension_numbers = #mhlo.dot<
// CHECK-SAME:     lhs_contracting_dimensions = [0],
// CHECK-SAME:     rhs_contracting_dimensions = [0]

package filepath_test

import (
	"fmt"
	"path/filepath"
)

func ExampleExt() {
	fmt.Printf("No dots: %q\n", filepath.Ext("index"))
	fmt.Printf("One dot: %q\n", filepath.Ext("index.js"))
	fmt.Printf("Two dots: %q\n", filepath.Ext("main.test.js"))
	// Output:
	// No dots: ""
	// One dot: ".js"
	// Two dots: ".js"

	case *parse.ContinueNode:
		panic(walkContinue)
	case *parse.IfNode:
		s.walkIfOrWith(parse.NodeIf, dot, node.Pipe, node.List, node.ElseList)
	case *parse.ListNode:
		for _, node := range node.Nodes {
			s.walk(dot, node)
		}
	case *parse.RangeNode:
		s.walkRange(dot, node)
	case *parse.TemplateNode:
		s.walkTemplate(dot, node)
	case *parse.TextNode:
		if _, err := s.wr.Write(node.Text); err != nil {
			s.writeError(err)

-- .info --
{"Version":"v1.0.0"}
-- .mod --
module example.com/dotname

go 1.16
-- go.mod --
module example.com/dotname

go 1.16
-- .dot/dot.go --

		return syscall.Getwd()
	}

	// Clumsy but widespread kludge:
	// if $PWD is set and matches ".", use it.
	dot, err := statNolog(".")
	if err != nil {
		return "", err
	}
	dir = Getenv("PWD")
	if len(dir) > 0 && dir[0] == '/' {
		d, err := statNolog(dir)
		if err == nil && SameFile(dot, d) {
			return dir, nil
		}
	}

	// If the operating system provides a Getwd call, use it.

! go build -mod=readonly nonexist
! stderr 'import lookup disabled'
! stderr 'missing dot'
stderr '^package nonexist is not in std \('$GOROOT'[/\\]src[/\\]nonexist\)$'

! go build nonexist
! stderr 'import lookup disabled'
! stderr 'missing dot'
stderr '^package nonexist is not in std \('$GOROOT'[/\\]src[/\\]nonexist\)$'