return withFunKind(kind, () => {
		// TODO:ES6 use `...`f
		const nArgs = new LiteralNumber(args.length)
		const opDeclareRest = opMap(opRestArg, rest =>
			makeDeclare(rest, new CallExpression(arraySliceCall, [idArguments, nArgs])))
		const argChecks = opIf(compileOptions.checks, () =>
			flatMapOps(args, opTypeCheckForLocalDeclare))

		const opDeclareThisAst = opIf(opDeclareThis !== null && !dontDeclareThis, () =>
			declareLexicalThis)

		const lead = cat(opDeclareRest, opDeclareThisAst, argChecks, leadStatements)

		const body = () => transpileBlock(block, {lead, opReturnType})
		const argAsts = args.map(transpileLocalDeclare)
		const id = opMap(verifyResults.opName(_), identifier)

		switch (kind) {
			case Funs.Async: {
				const plainBody = transpileBlock(block, {opReturnType})
				const genFunc = new FunctionExpression(null, [], plainBody, {generator: true})
				const ret = new ReturnStatement(msCall('async', genFunc))
				return new FunctionExpression(id, argAsts, new BlockStatement(cat(lead, ret)))
			}
			case Funs.Generator:
				return new FunctionExpression(id, argAsts, body(), {generator: true})
			case Funs.Plain:
				// TODO:ES6 Should be able to use rest args in arrow function
				return id === null && opDeclareThis === null && opDeclareRest === null ?
					new ArrowFunctionExpression(argAsts, body()) :
					new FunctionExpression(id, argAsts, body())
			default:
				throw new Error(String(kind))
		}
	})

function transpileSwitchPart(_: SwitchPart, isDo: boolean):  Array<SwitchCase> {
	const {values, result} = _

	const follow = opIf(isDo, () => new BreakStatement)
	/*
	We could just pass block.body for the switch lines, but instead
	enclose the body of the switch case in curly braces to ensure a new scope.
	That way this code works:
		switch (0) {
			case 0: {
				const a = 0
				return a
			}
			default: {
				// Without curly braces this would conflict with the other `a`.
				const a = 1
				a
			}
		}
	*/
	const block = transpileBlock(result, {follow})
	// If switch has multiple values, build up a statement like: `case 1: case 2: { doBlock() }`
	const cases: Array<SwitchCase> = []
	for (let i = 0; i < values.length - 1; i = i + 1)
		// These cases fallthrough to the one at the end.
		cases.push(loc(_, new SwitchCase(transpileVal(values[i]), [])))
	cases.push(loc(_, new SwitchCase(transpileVal(values[values.length - 1]), [block])))
	return cases
}

export function opTypeCheckForLocalDeclare(localDeclare: LocalDeclare): Op<Statement> {
	// TODO: Way to typecheck lazies
	return opIf(!localDeclare.isLazy, () =>
		opMap(localDeclare.opType, type =>
			new ExpressionStatement(msCall(
				'checkInstance',
				transpileVal(type),
				accessLocalDeclare(localDeclare),
				new LiteralString(localDeclare.name)))))
}

function parseSpacedFold(start: Val, rest: Tokens): Val {
	let acc = start
	for (let i = rest.start; i < rest.end; i = i + 1) {
		function restVal(): Val {
			return parseSpaced(rest.chopStart(i + 1))
		}

		const token = rest.tokens[i]
		const loc = token.loc
		if (token instanceof KeywordPlain)
			switch (token.kind) {
				case Kw.Ampersand:
					if (i === rest.end - 1)
						throw unexpected(token)
					i = i + 1
					acc = new FunMember(token.loc, acc, parseMemberName(rest.tokens[i]))
					break
				case Kw.Dot: {
					// If this were the last one,
					// it would not be a Kw.Dot but a Kw.ObjEntry
					assert(i < rest.end - 1)
					i = i + 1
					acc = new Member(token.loc, acc, parseMemberName(rest.tokens[i]))
					break
				}
				case Kw.Dot2:
					check(i < rest.end - 1, token.loc, _ => _.infiniteRange)
					return new Range(token.loc, acc, restVal(), false)
				case Kw.Dot3:
					return new Range(token.loc, acc, opIf(i < rest.end - 1, restVal), true)
				case Kw.Focus:
					acc = new Call(token.loc, acc, [LocalAccess.focus(loc)])
					break
				case Kw.Colon:
					return new InstanceOf(token.loc, acc, restVal())
				default:
					throw unexpected(token)
			}
		else if (token instanceof GroupBracket)
			acc = new Sub(loc, acc, parseExprParts(Tokens.of(token)))
		else if (token instanceof GroupParenthesis) {
			checkEmpty(Tokens.of(token), _ => _.parensOutsideCall)
			acc = new Call(loc, acc, [])
		} else if (token instanceof GroupQuote)
			acc = new QuoteTagged(loc, acc, parseQuote(Slice.of(token)))
		else
			throw unexpected(token)
	}
	return acc
}

function parseClassHeader(tokens: Tokens)
	: {opFields: Op<Array<Field>>, opSuperClass: Op<Val>, traits: Array<Val>} {
	const [fieldsTokens, [extendsTokens, traitTokens]] =
		tokens.getKeywordSections(Kw.Extends, Kw.Trait)
	return {
		opFields: opIf(!fieldsTokens.isEmpty(), () => fieldsTokens.map(_ => {
			const {name, opType, kind} = parseLocalParts(_)
			check(kind === LocalDeclares.Eager, _.loc, _ => _.todoLazyField)
			return new Field(_.loc, name, opType)
		})),
		opSuperClass: opMap(extendsTokens, parseExpr),
		traits: caseOp(traitTokens, parseExprParts, () => [])
	}
}

	constructor(
		loc: Loc,
		public args: Array<LocalDeclare>,
		public opRestArg: Op<LocalDeclare>,
		public block: Block,
		opts: FunBlockOptions = {}) {
		super(loc)
		const {kind, isThisFun, isDo, opReturnType} = applyDefaults(opts, {
			kind: Funs.Plain,
			isThisFun: false,
			isDo: false,
			opReturnType: null
		})
		this.kind = kind
		this.opDeclareThis = opIf(isThisFun, () => LocalDeclare.this(this.loc))
		this.isDo = isDo
		this.opReturnType = opReturnType
	}

function parseLocalPartsFromSpaced(tokens: Tokens, orMember: boolean = false)
	: {name: string, opType: Op<Val>, kind: LocalDeclares, isMember: boolean} {
	const [rest, kind, isMember] =
		isKeyword(Kw.Lazy, tokens.head()) ?
			[tokens.tail(), LocalDeclares.Lazy, false] :
			orMember && isKeyword(Kw.Dot, tokens.head()) ?
			[tokens.tail(), LocalDeclares.Eager, true] :
			[tokens, LocalDeclares.Eager, false]
	const name = parseLocalName(rest.head())
	const rest2 = rest.tail()
	const opType = opIf(!rest2.isEmpty(), () => {
		const colon = rest2.head()
		checkKeyword(Kw.Colon, colon)
		const tokensType = rest2.tail()
		checkNonEmpty(tokensType, _ => _.expectedAfterColon)
		return parseSpaced(tokensType)
	})
	return {name, opType, kind, isMember}
}

function opParseIteratee(tokens: Tokens): Op<Iteratee> {
	return opIf(!tokens.isEmpty(), () => parseIteratee(tokens))
}