| /* |
| * Copyright (C) 2017 Apple Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| "use strict"; |
| |
| class Checker extends Visitor { |
| constructor(program) |
| { |
| super(); |
| this._program = program; |
| this._currentStatement = null; |
| this._vertexEntryPoints = new Set(); |
| this._fragmentEntryPoints = new Set(); |
| } |
| |
| visitProgram(node) |
| { |
| let doStatement = statement => { |
| this._currentStatement = statement; |
| statement.visit(this); |
| } |
| |
| for (let type of node.types.values()) |
| doStatement(type); |
| for (let protocol of node.protocols.values()) |
| doStatement(protocol); |
| for (let funcs of node.functions.values()) { |
| for (let func of funcs) { |
| this.visitFunc(func); |
| } |
| } |
| for (let funcs of node.functions.values()) { |
| for (let func of funcs) |
| doStatement(func); |
| } |
| } |
| |
| _checkShaderType(node) |
| { |
| // FIXME: Relax these checks once we have implemented support for textures and samplers. |
| if (node.typeParameters.length != 0) |
| throw new WTypeError(node.origin.originString, "Entry point " + node.name + " must not have type arguments."); |
| let shaderFunc = node; |
| switch (node.shaderType) { |
| case "vertex": |
| if (this._vertexEntryPoints.has(node.name)) |
| throw new WTypeError(node.origin.originString, "Duplicate vertex entry point name " + node.name); |
| this._vertexEntryPoints.add(node.name); |
| break; |
| case "fragment": |
| if (this._fragmentEntryPoints.has(node.name)) |
| throw new WTypeError(node.origin.originString, "Duplicate fragment entry point name " + node.name); |
| this._fragmentEntryPoints.add(node.name); |
| break; |
| } |
| } |
| |
| _checkOperatorOverload(func, resolveFuncs) |
| { |
| if (Lexer.textIsIdentifier(func.name)) |
| return; // Not operator! |
| |
| if (!func.name.startsWith("operator")) |
| throw new Error("Bad operator overload name: " + func.name); |
| |
| let typeVariableTracker = new TypeVariableTracker(); |
| for (let parameterType of func.parameterTypes) |
| parameterType.visit(typeVariableTracker); |
| Node.visit(func.returnTypeForOverloadResolution, typeVariableTracker); |
| for (let typeParameter of func.typeParameters) { |
| if (!typeVariableTracker.set.has(typeParameter)) |
| throw new WTypeError(typeParameter.origin.originString, "Type parameter " + typeParameter + " to operator " + func.toDeclString() + " is not inferrable from value parameters"); |
| } |
| |
| let checkGetter = (kind) => { |
| let numExpectedParameters = kind == "index" ? 2 : 1; |
| if (func.parameters.length != numExpectedParameters) |
| throw new WTypeError(func.origin.originString, "Incorrect number of parameters for " + func.name + " (expected " + numExpectedParameters + ", got " + func.parameters.length + ")"); |
| if (func.parameterTypes[0].unifyNode.isPtr) |
| throw new WTypeError(func.origin.originString, "Cannot have getter for pointer type: " + func.parameterTypes[0]); |
| }; |
| |
| let checkSetter = (kind) => { |
| let numExpectedParameters = kind == "index" ? 3 : 2; |
| if (func.parameters.length != numExpectedParameters) |
| throw new WTypeError(func.origin.originString, "Incorrect number of parameters for " + func.name + " (expected " + numExpectedParameters + ", got " + func.parameters.length + ")"); |
| if (func.parameterTypes[0].unifyNode.isPtr) |
| throw new WTypeError(func.origin.originString, "Cannot have setter for pointer type: " + func.parameterTypes[0]); |
| if (!func.returnType.equals(func.parameterTypes[0])) |
| throw new WTypeError(func.origin.originString, "First parameter type and return type of setter must match (parameter was " + func.parameterTypes[0] + " but return was " + func.returnType + ")"); |
| let valueType = func.parameterTypes[numExpectedParameters - 1]; |
| let getterName = func.name.substr(0, func.name.length - 1); |
| let getterFuncs = resolveFuncs(getterName); |
| if (!getterFuncs) |
| throw new WTypeError(func.origin.originString, "Every setter must have a matching getter, but did not find any function named " + getterName + " to match " + func.name); |
| let argumentTypes = func.parameterTypes.slice(0, numExpectedParameters - 1); |
| let overload = resolveOverloadImpl(getterFuncs, [], argumentTypes, null); |
| if (!overload.func) |
| throw new WTypeError(func.origin.originString, "Did not find function named " + func.name + " with arguments " + argumentTypes + (overload.failures.length ? "; tried:\n" + overload.failures.join("\n") : "")); |
| let resultType = overload.func.returnType.substituteToUnification( |
| overload.func.typeParameters, overload.unificationContext); |
| if (!resultType.equals(valueType)) |
| throw new WTypeError(func.origin.originString, "Setter and getter must agree on value type (getter at " + overload.func.origin.originString + " says " + resultType + " while this setter says " + valueType + ")"); |
| }; |
| |
| let checkAnder = (kind) => { |
| let numExpectedParameters = kind == "index" ? 2 : 1; |
| if (func.parameters.length != numExpectedParameters) |
| throw new WTypeError(func.origin.originString, "Incorrect number of parameters for " + func.name + " (expected " + numExpectedParameters + ", got " + func.parameters.length + ")"); |
| if (!func.returnType.unifyNode.isPtr) |
| throw new WTypeError(func.origin.originString, "Return type of ander is not a pointer: " + func.returnType); |
| if (!func.parameterTypes[0].unifyNode.isRef) |
| throw new WTypeError(func.origin.originString, "Parameter to ander is not a reference: " + func.parameterTypes[0]); |
| }; |
| |
| switch (func.name) { |
| case "operator cast": |
| break; |
| case "operator++": |
| case "operator--": |
| if (func.parameters.length != 1) |
| throw new WTypeError(func.origin.originString, "Incorrect number of parameters for " + func.name + " (expected 1, got " + func.parameters.length + ")"); |
| if (!func.parameterTypes[0].equals(func.returnType)) |
| throw new WTypeError(func.origin.originString, "Parameter type and return type must match for " + func.name + " (parameter is " + func.parameterTypes[0] + " while return is " + func.returnType + ")"); |
| break; |
| case "operator+": |
| case "operator-": |
| if (func.parameters.length != 1 && func.parameters.length != 2) |
| throw new WTypeError(func.origin.originString, "Incorrect number of parameters for " + func.name + " (expected 1 or 2, got " + func.parameters.length + ")"); |
| break; |
| case "operator*": |
| case "operator/": |
| case "operator%": |
| case "operator&": |
| case "operator|": |
| case "operator^": |
| case "operator<<": |
| case "operator>>": |
| if (func.parameters.length != 2) |
| throw new WTypeError(func.origin.originString, "Incorrect number of parameters for " + func.name + " (expected 2, got " + func.parameters.length + ")"); |
| break; |
| case "operator~": |
| if (func.parameters.length != 1) |
| throw new WTypeError(func.origin.originString, "Incorrect number of parameters for " + func.name + " (expected 1, got " + func.parameters.length + ")"); |
| break; |
| case "operator==": |
| case "operator<": |
| case "operator<=": |
| case "operator>": |
| case "operator>=": |
| if (func.parameters.length != 2) |
| throw new WTypeError(func.origin.originString, "Incorrect number of parameters for " + func.name + " (expected 2, got " + func.parameters.length + ")"); |
| if (!func.returnType.equals(this._program.intrinsics.bool)) |
| throw new WTypeError(func.origin.originString, "Return type of " + func.name + " must be bool but was " + func.returnType); |
| break; |
| case "operator[]": |
| checkGetter("index"); |
| break; |
| case "operator[]=": |
| checkSetter("index"); |
| break; |
| case "operator&[]": |
| checkAnder("index"); |
| break; |
| default: |
| if (func.name.startsWith("operator.")) { |
| if (func.name.endsWith("=")) |
| checkSetter("dot"); |
| else |
| checkGetter("dot"); |
| break; |
| } |
| if (func.name.startsWith("operator&.")) { |
| checkAnder("dot"); |
| break; |
| } |
| throw new Error("Parser accepted unrecognized operator: " + func.name); |
| } |
| } |
| |
| visitFuncDef(node) |
| { |
| if (node.shaderType) |
| this._checkShaderType(node); |
| this._checkOperatorOverload(node, name => this._program.functions.get(name)); |
| node.body.visit(this); |
| } |
| |
| visitNativeFunc(node) |
| { |
| } |
| |
| visitProtocolDecl(node) |
| { |
| for (let signature of node.signatures) { |
| let typeVariableTracker = new TypeVariableTracker(); |
| for (let parameterType of signature.parameterTypes) |
| parameterType.visit(typeVariableTracker); |
| Node.visit(signature.returnTypeForOverloadResolution, typeVariableTracker); |
| for (let typeParameter of signature.typeParameters) { |
| if (!typeVariableTracker.set.has(typeParameter)) |
| throw WTypeError(typeParameter.origin.originString, "Type parameter to protocol signature not inferrable from value parameters"); |
| } |
| if (!typeVariableTracker.set.has(node.typeVariable)) |
| throw new WTypeError(signature.origin.originString, "Protocol's type variable (" + node.name + ") not mentioned in signature: " + signature); |
| this._checkOperatorOverload(signature, name => node.signaturesByName(name)); |
| } |
| } |
| |
| visitEnumType(node) |
| { |
| node.baseType.visit(this); |
| |
| let baseType = node.baseType.unifyNode; |
| |
| if (!baseType.isInt) |
| throw new WTypeError(node.origin.originString, "Base type of enum is not an integer: " + node.baseType); |
| |
| for (let member of node.members) { |
| if (!member.value) |
| continue; |
| |
| let memberType = member.value.visit(this); |
| if (!baseType.equalsWithCommit(memberType)) |
| throw new WTypeError(member.origin.originString, "Type of enum member " + member.value.name + " does not patch enum base type (member type is " + memberType + ", enum base type is " + node.baseType + ")"); |
| } |
| |
| let nextValue = baseType.defaultValue; |
| for (let member of node.members) { |
| if (member.value) { |
| nextValue = baseType.successorValue(member.value.unifyNode.valueForSelectedType); |
| continue; |
| } |
| |
| member.value = baseType.createLiteral(member.origin, nextValue); |
| nextValue = baseType.successorValue(nextValue); |
| } |
| |
| let memberArray = Array.from(node.members); |
| for (let i = 0; i < memberArray.length; ++i) { |
| let member = memberArray[i]; |
| for (let j = i + 1; j < memberArray.length; ++j) { |
| let otherMember = memberArray[j]; |
| if (baseType.valuesEqual(member.value.unifyNode.valueForSelectedType, otherMember.value.unifyNode.valueForSelectedType)) |
| throw new WTypeError(otherMember.origin.originString, "Duplicate enum member value (" + member.name + " has " + member.value + " while " + otherMember.name + " has " + otherMember.value + ")"); |
| } |
| } |
| |
| let foundZero = false; |
| for (let member of node.members) { |
| if (baseType.valuesEqual(member.value.unifyNode.valueForSelectedType, baseType.defaultValue)) { |
| foundZero = true; |
| break; |
| } |
| } |
| if (!foundZero) |
| throw new WTypeError(node.origin.originString, "Enum does not have a member with the value zero"); |
| } |
| |
| _checkTypeArguments(origin, typeParameters, typeArguments) |
| { |
| for (let i = 0; i < typeParameters.length; ++i) { |
| let argumentIsType = typeArguments[i] instanceof Type; |
| let result = typeArguments[i].visit(this); |
| if (argumentIsType) { |
| let result = typeArguments[i].inherits(typeParameters[i].protocol); |
| if (!result.result) |
| throw new WTypeError(origin.originString, "Type argument does not inherit protocol: " + result.reason); |
| } else { |
| if (!result.equalsWithCommit(typeParameters[i].type)) |
| throw new WTypeError(origin.originString, "Wrong type for constexpr"); |
| } |
| } |
| } |
| |
| visitTypeRef(node) |
| { |
| if (!node.type) |
| throw new Error("Type reference without a type in checker: " + node + " at " + node.origin); |
| if (!(node.type instanceof StructType)) |
| node.type.visit(this); |
| this._checkTypeArguments(node.origin, node.type.typeParameters, node.typeArguments); |
| } |
| |
| visitArrayType(node) |
| { |
| node.elementType.visit(this); |
| |
| if (!node.numElements.isConstexpr) |
| throw new WTypeError(node.origin.originString, "Array length must be constexpr"); |
| |
| let type = node.numElements.visit(this); |
| |
| if (!type.equalsWithCommit(this._program.intrinsics.uint32)) |
| throw new WTypeError(node.origin.originString, "Array length must be a uint32"); |
| } |
| |
| visitVariableDecl(node) |
| { |
| node.type.visit(this); |
| if (node.initializer) { |
| let lhsType = node.type; |
| let rhsType = node.initializer.visit(this); |
| if (!lhsType.equalsWithCommit(rhsType)) |
| throw new WTypeError(node.origin.originString, "Type mismatch in variable initialization: " + lhsType + " versus " + rhsType); |
| } |
| } |
| |
| visitAssignment(node) |
| { |
| let lhsType = node.lhs.visit(this); |
| if (!node.lhs.isLValue) |
| throw new WTypeError(node.origin.originString, "LHS of assignment is not an LValue: " + node.lhs + node.lhs.notLValueReasonString); |
| let rhsType = node.rhs.visit(this); |
| if (!lhsType.equalsWithCommit(rhsType)) |
| throw new WTypeError(node.origin.originString, "Type mismatch in assignment: " + lhsType + " versus " + rhsType); |
| node.type = lhsType; |
| return lhsType; |
| } |
| |
| visitIdentityExpression(node) |
| { |
| return node.target.visit(this); |
| } |
| |
| visitReadModifyWriteExpression(node) |
| { |
| let lhsType = node.lValue.visit(this); |
| if (!node.lValue.isLValue) |
| throw new WTypeError(node.origin.originString, "LHS of read-modify-write is not an LValue: " + node.lValue + node.lValue.notLValueReasonString); |
| node.oldValueVar.type = lhsType; |
| node.newValueVar.type = lhsType; |
| node.oldValueVar.visit(this); |
| node.newValueVar.visit(this); |
| let newValueType = node.newValueExp.visit(this); |
| if (!lhsType.equalsWithCommit(newValueType)) |
| return new WTypeError(node.origin.originString, "Type mismatch in read-modify-write: " + lhsType + " versus " + newValueType); |
| return node.resultExp.visit(this); |
| } |
| |
| visitAnonymousVariable(node) |
| { |
| if (!node.type) |
| throw new Error("Anonymous variable must know type before first appearance"); |
| } |
| |
| visitDereferenceExpression(node) |
| { |
| let type = node.ptr.visit(this).unifyNode; |
| if (!type.isPtr) |
| throw new WTypeError(node.origin.originString, "Type passed to dereference is not a pointer: " + type); |
| node.type = type.elementType; |
| node.addressSpace = type.addressSpace; |
| if (!node.addressSpace) |
| throw new Error("Null address space in type: " + type); |
| return node.type; |
| } |
| |
| visitMakePtrExpression(node) |
| { |
| let elementType = node.lValue.visit(this).unifyNode; |
| if (!node.lValue.isLValue) |
| throw new WTypeError(node.origin.originString, "Operand to & is not an LValue: " + node.lValue + node.lValue.notLValueReasonString); |
| |
| return new PtrType(node.origin, node.lValue.addressSpace, elementType); |
| } |
| |
| visitMakeArrayRefExpression(node) |
| { |
| let elementType = node.lValue.visit(this).unifyNode; |
| if (elementType.isPtr) { |
| node.become(new ConvertPtrToArrayRefExpression(node.origin, node.lValue)); |
| return new ArrayRefType(node.origin, elementType.addressSpace, elementType.elementType); |
| } |
| |
| if (!node.lValue.isLValue) |
| throw new WTypeError(node.origin.originString, "Operand to @ is not an LValue: " + node.lValue + node.lValue.notLValueReasonString); |
| |
| if (elementType.isArray) { |
| node.numElements = elementType.numElements; |
| elementType = elementType.elementType; |
| } else |
| node.numElements = UintLiteral.withType(node.origin, 1, this._program.intrinsics.uint32); |
| |
| return new ArrayRefType(node.origin, node.lValue.addressSpace, elementType); |
| } |
| |
| visitConvertToArrayRefExpression(node) |
| { |
| throw new Error("Should not exist yet."); |
| } |
| |
| _finishVisitingPropertyAccess(node, baseType, extraArgs, extraArgTypes) |
| { |
| baseType = baseType.visit(new AutoWrapper()) |
| node.baseType = baseType; |
| |
| // Such a type must exist. This may throw if it doesn't. |
| let typeForAnd = baseType.argumentTypeForAndOverload(node.origin); |
| if (!typeForAnd) |
| throw new Error("Cannot get typeForAnd"); |
| |
| let errorForGet; |
| let errorForAnd; |
| |
| try { |
| let result = CallExpression.resolve( |
| node.origin, node.possibleGetOverloads, this._currentStatement.typeParameters, |
| node.getFuncName, [], [node.base, ...extraArgs], [baseType, ...extraArgTypes], null); |
| node.callForGet = result.call; |
| node.resultTypeForGet = result.resultType; |
| } catch (e) { |
| if (!(e instanceof WTypeError)) |
| throw e; |
| errorForGet = e; |
| } |
| |
| try { |
| let baseForAnd = baseType.argumentForAndOverload(node.origin, node.base); |
| |
| let result = CallExpression.resolve( |
| node.origin, node.possibleAndOverloads, this._currentStatement.typeParameters, |
| node.andFuncName, [], [baseForAnd, ...extraArgs], [typeForAnd, ...extraArgTypes], |
| null); |
| node.callForAnd = result.call; |
| node.resultTypeForAnd = result.resultType.unifyNode.returnTypeFromAndOverload(node.origin); |
| } catch (e) { |
| if (!(e instanceof WTypeError)) |
| throw e; |
| errorForAnd = e; |
| } |
| |
| if (!node.resultTypeForGet && !node.resultTypeForAnd) { |
| throw new WTypeError( |
| node.origin.originString, |
| "Cannot resolve access; tried by-value:\n" + |
| errorForGet.typeErrorMessage + "\n" + |
| "and tried by-pointer:\n" + |
| errorForAnd.typeErrorMessage); |
| } |
| |
| if (node.resultTypeForGet && node.resultTypeForAnd |
| && !node.resultTypeForGet.equals(node.resultTypeForAnd)) |
| throw new WTypeError(node.origin.originString, "Result type resolved by-value (" + node.resultTypeForGet + ") does not match result type resolved by-pointer (" + node.resultTypeForAnd + ")"); |
| |
| try { |
| let result = CallExpression.resolve( |
| node.origin, node.possibleSetOverloads, this._currentStatement.typeParameters, |
| node.setFuncName, [], [node.base, ...extraArgs, null], [baseType, ...extraArgTypes, node.resultType], null); |
| node.callForSet = result.call; |
| if (!result.resultType.equals(baseType)) |
| throw new WTypeError(node.origin.originString, "Result type of setter " + result.call.func + " is not the base type " + baseType); |
| } catch (e) { |
| if (!(e instanceof WTypeError)) |
| throw e; |
| node.errorForSet = e; |
| } |
| |
| // OK, now we need to determine if we are an lvalue. We are an lvalue if we can be assigned to. We can |
| // be assigned to if we have an ander or setter. But it's weirder than that. We also need the base to be |
| // an lvalue, except unless the base is an array reference. |
| if (!node.callForAnd && !node.callForSet) { |
| node.isLValue = false; |
| node.notLValueReason = |
| "Have neither ander nor setter. Tried setter:\n" + |
| node.errorForSet.typeErrorMessage + "\n" + |
| "and tried ander:\n" + |
| errorForAnd.typeErrorMessage; |
| } else if (!node.base.isLValue && !baseType.isArrayRef) { |
| node.isLValue = false; |
| node.notLValueReason = "Base of property access is neither a lvalue nor an array reference"; |
| } else { |
| node.isLValue = true; |
| node.addressSpace = node.base.isLValue ? node.base.addressSpace : baseType.addressSpace; |
| } |
| |
| return node.resultType; |
| } |
| |
| visitDotExpression(node) |
| { |
| let structType = node.struct.visit(this).unifyNode; |
| return this._finishVisitingPropertyAccess(node, structType, [], []); |
| } |
| |
| visitIndexExpression(node) |
| { |
| let arrayType = node.array.visit(this).unifyNode; |
| let indexType = node.index.visit(this); |
| |
| return this._finishVisitingPropertyAccess(node, arrayType, [node.index], [indexType]); |
| } |
| |
| visitVariableRef(node) |
| { |
| if (!node.variable.type) |
| throw new Error("Variable has no type: " + node.variable); |
| return node.variable.type; |
| } |
| |
| visitReturn(node) |
| { |
| if (node.value) { |
| let resultType = node.value.visit(this); |
| if (!resultType) |
| throw new Error("Null result type from " + node.value); |
| if (!node.func.returnType.equalsWithCommit(resultType)) |
| throw new WTypeError(node.origin.originString, "Trying to return " + resultType + " in a function that returns " + node.func.returnType); |
| return; |
| } |
| |
| if (!node.func.returnType.equalsWithCommit(this._program.intrinsics.void)) |
| throw new WTypeError(node.origin.originString, "Non-void function must return a value"); |
| } |
| |
| visitGenericLiteral(node) |
| { |
| return node.type; |
| } |
| |
| visitNullLiteral(node) |
| { |
| return node.type; |
| } |
| |
| visitBoolLiteral(node) |
| { |
| return this._program.intrinsics.bool; |
| } |
| |
| visitEnumLiteral(node) |
| { |
| return node.member.enumType; |
| } |
| |
| _requireBool(expression) |
| { |
| let type = expression.visit(this); |
| if (!type) |
| throw new Error("Expression has no type, but should be bool: " + expression); |
| if (!type.equals(this._program.intrinsics.bool)) |
| throw new WTypeError("Expression isn't a bool: " + expression); |
| } |
| |
| visitLogicalNot(node) |
| { |
| this._requireBool(node.operand); |
| return this._program.intrinsics.bool; |
| } |
| |
| visitLogicalExpression(node) |
| { |
| this._requireBool(node.left); |
| this._requireBool(node.right); |
| return this._program.intrinsics.bool; |
| } |
| |
| visitIfStatement(node) |
| { |
| this._requireBool(node.conditional); |
| node.body.visit(this); |
| if (node.elseBody) |
| node.elseBody.visit(this); |
| } |
| |
| visitWhileLoop(node) |
| { |
| this._requireBool(node.conditional); |
| node.body.visit(this); |
| } |
| |
| visitDoWhileLoop(node) |
| { |
| node.body.visit(this); |
| this._requireBool(node.conditional); |
| } |
| |
| visitForLoop(node) |
| { |
| if (node.initialization) |
| node.initialization.visit(this); |
| if (node.condition) |
| this._requireBool(node.condition); |
| if (node.increment) |
| node.increment.visit(this); |
| node.body.visit(this); |
| } |
| |
| visitSwitchStatement(node) |
| { |
| let type = node.value.visit(this).commit(); |
| |
| if (!type.unifyNode.isInt && !(type.unifyNode instanceof EnumType)) |
| throw new WTypeError(node.origin.originString, "Cannot switch on non-integer/non-enum type: " + type); |
| |
| node.type = type; |
| |
| let hasDefault = false; |
| |
| for (let switchCase of node.switchCases) { |
| switchCase.body.visit(this); |
| |
| if (switchCase.isDefault) { |
| hasDefault = true; |
| continue; |
| } |
| |
| if (!switchCase.value.isConstexpr) |
| throw new WTypeError(switchCase.origin.originString, "Switch case not constexpr: " + switchCase.value); |
| |
| let caseType = switchCase.value.visit(this); |
| if (!type.equalsWithCommit(caseType)) |
| throw new WTypeError(switchCase.origin.originString, "Switch case type does not match switch value type (case type is " + caseType + " but switch value type is " + type + ")"); |
| } |
| |
| for (let i = 0; i < node.switchCases.length; ++i) { |
| let firstCase = node.switchCases[i]; |
| for (let j = i + 1; j < node.switchCases.length; ++j) { |
| let secondCase = node.switchCases[j]; |
| |
| if (firstCase.isDefault != secondCase.isDefault) |
| continue; |
| |
| if (firstCase.isDefault) |
| throw new WTypeError(secondCase.origin.originString, "Duplicate default case in switch statement"); |
| |
| let valuesEqual = type.unifyNode.valuesEqual( |
| firstCase.value.unifyNode.valueForSelectedType, |
| secondCase.value.unifyNode.valueForSelectedType); |
| if (valuesEqual) |
| throw new WTypeError(secondCase.origin.originString, "Duplicate case in switch statement for value " + firstCase.value.unifyNode.valueForSelectedType); |
| } |
| } |
| |
| if (!hasDefault) { |
| let includedValues = new Set(); |
| for (let switchCase of node.switchCases) |
| includedValues.add(switchCase.value.unifyNode.valueForSelectedType); |
| |
| for (let {value, name} of type.unifyNode.allValues()) { |
| if (!includedValues.has(value)) |
| throw new WTypeError(node.origin.originString, "Value not handled by switch statement: " + name); |
| } |
| } |
| } |
| |
| visitCommaExpression(node) |
| { |
| let result = null; |
| for (let expression of node.list) |
| result = expression.visit(this); |
| return result; |
| } |
| |
| visitCallExpression(node) |
| { |
| let typeArguments = node.typeArguments.map(typeArgument => typeArgument.visit(this)); |
| let argumentTypes = node.argumentList.map(argument => { |
| let newArgument = argument.visit(this); |
| if (!newArgument) |
| throw new Error("visitor returned null for " + argument); |
| return newArgument.visit(new AutoWrapper()); |
| }); |
| |
| node.argumentTypes = argumentTypes; |
| if (node.returnType) |
| node.returnType.visit(this); |
| |
| let result = node.resolve(node.possibleOverloads, this._currentStatement.typeParameters, typeArguments); |
| return result; |
| } |
| } |
| |
