}
		})
	}
}

func errorPath(err error) string {
	var perr *PathError
	if !errors.As(err, &perr) {
		return ""
	}
	return perr.Path
}

func TestReadDirPath(t *testing.T) {
	fsys := os.DirFS(t.TempDir())
	_, err1 := ReadDir(fsys, "non-existent")
	_, err2 := ReadDir(struct{ FS }{fsys}, "non-existent")
	if s1, s2 := errorPath(err1), errorPath(err2); s1 != s2 {

	}
}

func TestReadFilePath(t *testing.T) {
	fsys := os.DirFS(t.TempDir())
	_, err1 := ReadFile(fsys, "non-existent")
	_, err2 := ReadFile(struct{ FS }{fsys}, "non-existent")
	if s1, s2 := errorPath(err1), errorPath(err2); s1 != s2 {
		t.Fatalf("s1: %s != s2: %s", s1, s2)
	}

                        .append(getCanonicalPath())
                        .append(", failed paths:\n");
                    for (String errorPath : errorPaths) {
                        builder.append("\t- ").append(errorPath).append("\n");
                    }
                    throw new IOException(builder.toString());
                }
            }
        } else if (exists()) {
            if (!delete()) {

	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		executor := &fakeExecutor{
			t:            t,
			testName:     testName,
			errorData:    errorData,
			stdoutData:   stdoutData,
			stderrData:   stderrData,

	}

	if len(lhs) != cr {
		if r, ok := rhs[0].(*ir.CallExpr); ok && len(rhs) == 1 {
			if r.Type() != nil {
				base.ErrorfAt(stmt.Pos(), errors.WrongAssignCount, "assignment mismatch: %d variable%s but %v returns %d value%s", len(lhs), plural(len(lhs)), r.Fun, cr, plural(cr))
			}
		} else {

		for _, pattern := range e.Patterns {
			files, ok := base.Flag.Cfg.Embed.Patterns[pattern]
			if !ok {
				base.ErrorfAt(e.Pos, 0, "invalid go:embed: build system did not map pattern: %s", pattern)
			}
			for _, file := range files {
				if base.Flag.Cfg.Embed.Files[file] == "" {
					base.ErrorfAt(e.Pos, 0, "invalid go:embed: build system did not map file: %s", file)
					continue
				}
				if !have[file] {

     */
    @Override
    public void setResponse ( CommonServerMessageBlockResponse msg ) {

    }


    /**
     * @return the errorData
     */
    public final byte[] getErrorData () {
        return this.errorData;
    }


    /**
     * @return the errorContextCount
     */
    public final byte getErrorContextCount () {
        return this.errorContextCount;

func (s *scanner) errorf(format string, args ...interface{}) {
	s.error(fmt.Sprintf(format, args...))
}

// errorAtf reports an error at a byte column offset relative to the current token start.
func (s *scanner) errorAtf(offset int, format string, args ...interface{}) {
	s.errh(s.line, s.col+uint(offset), fmt.Sprintf(format, args...))
}

		default:
			base.ErrorfAt(f.Pos(), 0, "go:wasmimport %s %s: unsupported parameter type %s", f.WasmImport.Module, f.WasmImport.Name, t.String())
		}
		wfs[i].Offset = p.FrameOffset(result)
	}
	return wfs
}

func resultsToWasmFields(f *ir.Func, result *abi.ABIParamResultInfo, abiParams []abi.ABIParamAssignment) []obj.WasmField {
	if len(abiParams) > 1 {

			funcs[fn] = nowritebarrierrecCall{}
			q.PushRight(fn.Nname)
		}
		// Check go:nowritebarrier functions.
		if fn.Pragma&ir.Nowritebarrier != 0 && fn.WBPos.IsKnown() {
			base.ErrorfAt(fn.WBPos, 0, "write barrier prohibited")
		}
	}

	// Perform a BFS of the call graph from all
	// go:nowritebarrierrec functions.
	enqueue := func(src, target *ir.Func, pos src.XPos) {