mlir::Type MlrtDialect::parseType(mlir::DialectAsmParser &parser) const {
  llvm::StringRef keyword;
  if (parser.parseKeyword(&keyword)) return mlir::Type();

  if (keyword == "future") return FutureType::get(getContext());
  if (keyword == "promise") return PromiseType::get(getContext());
  if (keyword == "async_handle") return AsyncHandleType::get(getContext());

  parser.emitError(parser.getNameLoc(), "unknown type: ") << keyword;

import static org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.PomDomParser.AddDTDFilterInputStream;
import static org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.PomDomParser.getAllChilds;
import static org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.PomDomParser.getFirstChildElement;
import static org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.PomDomParser.getFirstChildText;

        "vararg"        | "Groovy dynamic dispatch" | { testVararg(it, it, it) }    | true           | "testVararg(Object...)"
    }

    def 'access to a #kind of a Groovy property from a #caller caller is intercepted as #expected for multiple types with the same method names'() {
        when:
        def firstIntercepted = interceptedInterceptorTestReceiver(shouldDelegate, invocation)

                maybeApplyInterceptor(ccs, caller, flags, interceptors.get(InterceptScope.readsOfPropertiesNamed(name)));
                break;
            case "init":
                maybeApplyInterceptor(ccs, caller, flags, dispatchingConstructorInterceptor);
                break;
        }
        return ccs;
    }

TensorFlow and LLVM:
  * Flags before the first '--' are parsed by tensorflow::InitMain while those
    post are parsed by LLVM's command line parser.
  * If there is no separator, then no flags are parsed by InitMain and only
    LLVM command line parser used.e
The above help options reported are for LLVM's parser, run with `--help --` for
TensorFlow's help.
)");

namespace tensorflow {

InitMlir::InitMlir(int *argc, char ***argv) {

func main() {
	fmt.Println(hello) // line comment 3
}
`

	// Create the AST by parsing src.
	fset := token.NewFileSet() // positions are relative to fset
	f, err := parser.ParseFile(fset, "src.go", src, parser.ParseComments)
	if err != nil {
		panic(err)
	}

	// Create an ast.CommentMap from the ast.File's comments.
	// This helps keeping the association between comments
	// and AST nodes.

    if (!symbol_uses.has_value()) {
      return failure();
    }
    for (auto use : *symbol_uses) {
      Operation* caller = use.getUser();
      bool changed = false;
      rewriter.startOpModification(caller);
      for (auto [result, type] :
           llvm::zip(caller->getResults(), return_types)) {
        if (result.getType() != type) {
          result.setType(type);
          changed = true;
        }

// Copyright 2024 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package ast_test

import (
	"go/ast"
	"go/parser"
	"go/token"
	"testing"
)

func TestPreorderBreak(t *testing.T) {
	// This test checks that Preorder correctly handles a break statement while
	// in the middle of walking a node. Previously, incorrect handling of the

		case '_', '*':
			parser = parseEmph
		case '.':
			if p.SmartDot {
				parser = parseDot
			}
		case '-':
			if p.SmartDash {
				parser = parseDash
			}
		case '"', '\'':
			if p.SmartQuote {
				parser = parseEmph
			}
		case '~':
			if p.Strikethrough {
				parser = parseEmph
			}
		case '\n': // TODO what about eof
			parser = parseBreak
		case '&':
			parser = parseHTMLEntity

     * to be the {@code expectedReceiver} passed to the constructor.
     *
     * @param invocation the arguments supplied by the caller
     * @param consumer the class that invokes the intercepted call
     * @return the value to return to the caller
     * @throws Throwable if necessary to propagate it to the caller
     */
    protected abstract Object interceptSafe(Invocation invocation, String consumer) throws Throwable;