radiance · commit

Re-order `visit` match for better performance

57e40912734128f7d05e57ad63ac424f1e210a35c6d901d88d7066fd153b5e87

Alexis Sellier committed 1 month ago 1 parent 6d184f20

lib/std/lang/resolver.rad +26 -35

{
    if let ty = typeFor(self, node) {
        return ty;
    }
    match node.value {
        case ast::NodeValue::Ident(name) => {
            let sym = findAnySymbol(self.scope, name)
                else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));
            setNodeSymbol(self, node, sym);
            match sym.data {
                case SymbolData::Value { type, .. } =>
                    return setNodeType(self, node, type),
                case SymbolData::Constant { type, value } => {
                    if let val = value {
                        setNodeConstValue(self, node, val);
                    }
                    return setNodeType(self, node, type);
                },
                case SymbolData::Type(t) =>
                    return setNodeType(self, node, Type::Nominal(t)),
                case SymbolData::Variant { .. } =>
                    return Type::Void,
                case SymbolData::Module { .. } =>
                    throw emitError(self, node, ErrorKind::UnexpectedModuleName),
                case SymbolData::Trait(_) =>
                    throw emitError(self, node, ErrorKind::UnexpectedTraitName),
            }
        },
        case ast::NodeValue::Call(call) => return try resolveCall(self, node, call, CallCtx::Normal),
        case ast::NodeValue::FieldAccess(access) => return try resolveFieldAccess(self, node, access),
        case ast::NodeValue::BinOp(binop) => return try resolveBinOp(self, node, binop),
        case ast::NodeValue::Block(block) => return try resolveBlock(self, node, block),
        case ast::NodeValue::Let(decl) => return try resolveLet(self, node, decl),
        case ast::NodeValue::ConstDecl(decl) => return try resolveConstOrStatic(
            self, node, decl.ident, decl.type, decl.value, decl.attrs, true
        ),

            return setNodeType(self, node, Type::Never);
        },
        case ast::NodeValue::Match(sw) => return try resolveMatch(self, node, sw),
        case ast::NodeValue::MatchProng(_) => panic "visit: `MatchProng` not handled here",
        case ast::NodeValue::LetElse(letElse) => return try resolveLetElse(self, node, letElse),
        case ast::NodeValue::Call(call) => return try resolveCall(self, node, call, CallCtx::Normal),
        case ast::NodeValue::BuiltinCall { kind, args } => return try resolveBuiltinCall(self, node, kind, args),
        case ast::NodeValue::Assign(assign) => return try resolveAssign(self, node, assign),
        case ast::NodeValue::RecordLit(lit) => return try resolveRecordLit(self, node, lit, hint),
        case ast::NodeValue::ArrayLit(items) => return try resolveArrayLit(self, node, items, hint),
        case ast::NodeValue::ArrayRepeatLit(lit) => return try resolveArrayRepeat(self, node, lit, hint),
        case ast::NodeValue::Subscript { container, index } => return try resolveSubscript(self, node, container, index),
        case ast::NodeValue::FieldAccess(access) => return try resolveFieldAccess(self, node, access),
        case ast::NodeValue::ScopeAccess(access) => return try resolveScopeAccess(self, node, access),
        case ast::NodeValue::AddressOf(addr) => return try resolveAddressOf(self, node, addr, hint),
        case ast::NodeValue::Deref(target) => return try resolveDeref(self, node, target, hint),
        case ast::NodeValue::As(expr) => return try resolveAs(self, node, expr),
        case ast::NodeValue::Range(range) => return try resolveRange(self, node, range),

                item: allocType(self, Type::U8),
                mutable: false
            });
            return setNodeType(self, node, Type::Void);
        },
        case ast::NodeValue::BinOp(binop) => return try resolveBinOp(self, node, binop),
        case ast::NodeValue::UnOp(unop) => return try resolveUnOp(self, node, unop),
        case ast::NodeValue::ExprStmt(expr) => {
            // Pass `Void` as expected type to indicate value is discarded.
            let exprTy = try visit(self, expr, Type::Void);
            return setNodeType(self, node, unifyBranches(exprTy, Type::Void));
        },
        case ast::NodeValue::TypeSig(sig) => return try inferTypeSig(self, node, sig),
        case ast::NodeValue::Ident(name) => {
            let sym = findAnySymbol(self.scope, name)
                else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));
            setNodeSymbol(self, node, sym);

            // TODO: See if we can unify this with `resolvePath`, ie. scope access.
            match sym.data {
                case SymbolData::Value { type, .. } => {
                    return setNodeType(self, node, type);
                },
                case SymbolData::Constant { type, value } => {
                    // Propagate constant value.
                    if let val = value {
                        setNodeConstValue(self, node, val);
                    }
                    return setNodeType(self, node, type);
                },
                case SymbolData::Type(t) => {
                    return setNodeType(self, node, Type::Nominal(t));
                },
                case SymbolData::Variant { .. } => {
                    return Type::Void;
                },
                case SymbolData::Module { .. } => {
                    // Module identifiers alone aren't valid expressions.
                    throw emitError(self, node, ErrorKind::UnexpectedModuleName);
                }
                case SymbolData::Trait(_) => {
                    throw emitError(self, node, ErrorKind::UnexpectedTraitName);
                }
            }
        },
        case ast::NodeValue::Super => {
            // `super` by itself is invalid, must be used in scope access.
            throw emitError(self, node, ErrorKind::InvalidModulePath);
        },
        case ast::NodeValue::Nil => {

2536	2536		{
2537	2537		if let ty = typeFor(self, node) {
2538	2538		return ty;
2539	2539		}
2540	2540		match node.value {
	2541	+	case ast::NodeValue::Ident(name) => {
	2542	+	let sym = findAnySymbol(self.scope, name)
	2543	+	else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));
	2544	+	setNodeSymbol(self, node, sym);
	2545	+	match sym.data {
	2546	+	case SymbolData::Value { type, .. } =>
	2547	+	return setNodeType(self, node, type),
	2548	+	case SymbolData::Constant { type, value } => {
	2549	+	if let val = value {
	2550	+	setNodeConstValue(self, node, val);
	2551	+	}
	2552	+	return setNodeType(self, node, type);
	2553	+	},
	2554	+	case SymbolData::Type(t) =>
	2555	+	return setNodeType(self, node, Type::Nominal(t)),
	2556	+	case SymbolData::Variant { .. } =>
	2557	+	return Type::Void,
	2558	+	case SymbolData::Module { .. } =>
	2559	+	throw emitError(self, node, ErrorKind::UnexpectedModuleName),
	2560	+	case SymbolData::Trait(_) =>
	2561	+	throw emitError(self, node, ErrorKind::UnexpectedTraitName),
	2562	+	}
	2563	+	},
	2564	+	case ast::NodeValue::Call(call) => return try resolveCall(self, node, call, CallCtx::Normal),
	2565	+	case ast::NodeValue::FieldAccess(access) => return try resolveFieldAccess(self, node, access),
	2566	+	case ast::NodeValue::BinOp(binop) => return try resolveBinOp(self, node, binop),
2541	2567		case ast::NodeValue::Block(block) => return try resolveBlock(self, node, block),
2542	2568		case ast::NodeValue::Let(decl) => return try resolveLet(self, node, decl),
2543	2569		case ast::NodeValue::ConstDecl(decl) => return try resolveConstOrStatic(
2544	2570		self, node, decl.ident, decl.type, decl.value, decl.attrs, true
2545	2571		),

2569	2595		return setNodeType(self, node, Type::Never);
2570	2596		},
2571	2597		case ast::NodeValue::Match(sw) => return try resolveMatch(self, node, sw),
2572	2598		case ast::NodeValue::MatchProng(_) => panic "visit: `MatchProng` not handled here",
2573	2599		case ast::NodeValue::LetElse(letElse) => return try resolveLetElse(self, node, letElse),
2574		-	case ast::NodeValue::Call(call) => return try resolveCall(self, node, call, CallCtx::Normal),
2575	2600		case ast::NodeValue::BuiltinCall { kind, args } => return try resolveBuiltinCall(self, node, kind, args),
2576	2601		case ast::NodeValue::Assign(assign) => return try resolveAssign(self, node, assign),
2577	2602		case ast::NodeValue::RecordLit(lit) => return try resolveRecordLit(self, node, lit, hint),
2578	2603		case ast::NodeValue::ArrayLit(items) => return try resolveArrayLit(self, node, items, hint),
2579	2604		case ast::NodeValue::ArrayRepeatLit(lit) => return try resolveArrayRepeat(self, node, lit, hint),
2580	2605		case ast::NodeValue::Subscript { container, index } => return try resolveSubscript(self, node, container, index),
2581		-	case ast::NodeValue::FieldAccess(access) => return try resolveFieldAccess(self, node, access),
2582	2606		case ast::NodeValue::ScopeAccess(access) => return try resolveScopeAccess(self, node, access),
2583	2607		case ast::NodeValue::AddressOf(addr) => return try resolveAddressOf(self, node, addr, hint),
2584	2608		case ast::NodeValue::Deref(target) => return try resolveDeref(self, node, target, hint),
2585	2609		case ast::NodeValue::As(expr) => return try resolveAs(self, node, expr),
2586	2610		case ast::NodeValue::Range(range) => return try resolveRange(self, node, range),

2600	2624		item: allocType(self, Type::U8),
2601	2625		mutable: false
2602	2626		});
2603	2627		return setNodeType(self, node, Type::Void);
2604	2628		},
2605		-	case ast::NodeValue::BinOp(binop) => return try resolveBinOp(self, node, binop),
2606	2629		case ast::NodeValue::UnOp(unop) => return try resolveUnOp(self, node, unop),
2607	2630		case ast::NodeValue::ExprStmt(expr) => {
2608	2631		// Pass `Void` as expected type to indicate value is discarded.
2609	2632		let exprTy = try visit(self, expr, Type::Void);
2610	2633		return setNodeType(self, node, unifyBranches(exprTy, Type::Void));
2611	2634		},
2612	2635		case ast::NodeValue::TypeSig(sig) => return try inferTypeSig(self, node, sig),
2613		-	case ast::NodeValue::Ident(name) => {
2614		-	let sym = findAnySymbol(self.scope, name)
2615		-	else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));
2616		-	setNodeSymbol(self, node, sym);
2617		-
2618		-	// TODO: See if we can unify this with `resolvePath`, ie. scope access.
2619		-	match sym.data {
2620		-	case SymbolData::Value { type, .. } => {
2621		-	return setNodeType(self, node, type);
2622		-	},
2623		-	case SymbolData::Constant { type, value } => {
2624		-	// Propagate constant value.
2625		-	if let val = value {
2626		-	setNodeConstValue(self, node, val);
2627		-	}
2628		-	return setNodeType(self, node, type);
2629		-	},
2630		-	case SymbolData::Type(t) => {
2631		-	return setNodeType(self, node, Type::Nominal(t));
2632		-	},
2633		-	case SymbolData::Variant { .. } => {
2634		-	return Type::Void;
2635		-	},
2636		-	case SymbolData::Module { .. } => {
2637		-	// Module identifiers alone aren't valid expressions.
2638		-	throw emitError(self, node, ErrorKind::UnexpectedModuleName);
2639		-	}
2640		-	case SymbolData::Trait(_) => {
2641		-	throw emitError(self, node, ErrorKind::UnexpectedTraitName);
2642		-	}
2643		-	}
2644		-	},
2645	2636		case ast::NodeValue::Super => {
2646	2637		// `super` by itself is invalid, must be used in scope access.
2647	2638		throw emitError(self, node, ErrorKind::InvalidModulePath);
2648	2639		},
2649	2640		case ast::NodeValue::Nil => {