use of org.wso2.ballerinalang.compiler.semantics.analyzer.Types in project ballerina by ballerina-lang.
the class TypeChecker method visit.
public void visit(BLangTypeConversionExpr conversionExpr) {
// Set error type as the actual type.
// List<BType> actualTypes = getListWithErrorTypes(expTypes.size());
List<BType> actualTypes;
BType targetType = symResolver.resolveTypeNode(conversionExpr.typeNode, env);
conversionExpr.targetType = targetType;
BType sourceType = checkExpr(conversionExpr.expr, env, Lists.of(symTable.noType)).get(0);
if (conversionExpr.transformerInvocation == null) {
// Lookup for built-in type conversion operator symbol
BSymbol symbol = symResolver.resolveConversionOperator(sourceType, targetType);
if (symbol == symTable.notFoundSymbol) {
// If not found, look for unnamed transformers for the given types
actualTypes = checkUnNamedTransformerInvocation(conversionExpr, sourceType, targetType);
} else {
BConversionOperatorSymbol conversionSym = (BConversionOperatorSymbol) symbol;
conversionExpr.conversionSymbol = conversionSym;
actualTypes = getActualTypesOfConversionExpr(conversionExpr, targetType, sourceType, conversionSym);
}
} else {
actualTypes = checkNamedTransformerInvocation(conversionExpr, sourceType, targetType);
}
resultTypes = types.checkTypes(conversionExpr, actualTypes, expTypes);
}
use of org.wso2.ballerinalang.compiler.semantics.analyzer.Types in project ballerina by ballerina-lang.
the class TypeChecker method checkInvocationParam.
private List<BType> checkInvocationParam(BLangInvocation iExpr) {
List<BType> paramTypes = ((BInvokableType) iExpr.symbol.type).getParameterTypes();
int requiredParamsCount;
if (iExpr.symbol.tag == SymTag.VARIABLE) {
// Here we assume function pointers can have only required params.
// And assume that named params and rest params are not supported.
requiredParamsCount = paramTypes.size();
} else {
requiredParamsCount = ((BInvokableSymbol) iExpr.symbol).params.size();
}
// Split the different argument types: required args, named args and rest args
int i = 0;
BLangExpression vararg = null;
for (BLangExpression expr : iExpr.argExprs) {
switch(expr.getKind()) {
case NAMED_ARGS_EXPR:
iExpr.namedArgs.add((BLangNamedArgsExpression) expr);
break;
case REST_ARGS_EXPR:
vararg = expr;
break;
default:
if (i < requiredParamsCount) {
iExpr.requiredArgs.add(expr);
} else {
iExpr.restArgs.add(expr);
}
i++;
break;
}
}
return checkInvocationArgs(iExpr, paramTypes, requiredParamsCount, vararg);
}
use of org.wso2.ballerinalang.compiler.semantics.analyzer.Types in project ballerina by ballerina-lang.
the class TypeChecker method visit.
public void visit(BLangBinaryExpr binaryExpr) {
BType lhsType = checkExpr(binaryExpr.lhsExpr, env).get(0);
BType rhsType = checkExpr(binaryExpr.rhsExpr, env).get(0);
// Set error type as the actual type.
BType actualType = symTable.errType;
// Look up operator symbol if both rhs and lhs types are error types
if (lhsType != symTable.errType && rhsType != symTable.errType) {
BSymbol opSymbol = symResolver.resolveBinaryOperator(binaryExpr.opKind, lhsType, rhsType);
if (opSymbol == symTable.notFoundSymbol) {
dlog.error(binaryExpr.pos, DiagnosticCode.BINARY_OP_INCOMPATIBLE_TYPES, binaryExpr.opKind, lhsType, rhsType);
} else {
binaryExpr.opSymbol = (BOperatorSymbol) opSymbol;
actualType = opSymbol.type.getReturnTypes().get(0);
}
}
resultTypes = types.checkTypes(binaryExpr, Lists.of(actualType), expTypes);
}
use of org.wso2.ballerinalang.compiler.semantics.analyzer.Types in project ballerina by ballerina-lang.
the class Desugar method getInitExpr.
private BLangExpression getInitExpr(BType type) {
// Don't need to create an empty init expressions if the type allows null.
if (type.isNullable()) {
return null;
}
switch(type.tag) {
case TypeTags.INT:
case TypeTags.FLOAT:
case TypeTags.BOOLEAN:
case TypeTags.STRING:
case TypeTags.BLOB:
// Int, float, boolean, string, blob types will get default values from VM side.
break;
case TypeTags.JSON:
return new BLangJSONLiteral(new ArrayList<>(), type);
case TypeTags.XML:
return new BLangXMLSequenceLiteral(type);
case TypeTags.TABLE:
return new BLangTableLiteral(type);
case TypeTags.STREAM:
return new BLangStreamLiteral(type, null);
case TypeTags.MAP:
return new BLangMapLiteral(new ArrayList<>(), type);
case TypeTags.STRUCT:
if (((BStructSymbol) type.tsymbol).isObject) {
return new BLangTypeInit();
}
return new BLangStructLiteral(new ArrayList<>(), type);
case TypeTags.ARRAY:
BLangArrayLiteral array = new BLangArrayLiteral();
array.exprs = new ArrayList<>();
array.type = type;
return rewriteExpr(array);
default:
break;
}
return null;
}
use of org.wso2.ballerinalang.compiler.semantics.analyzer.Types in project ballerina by ballerina-lang.
the class IterableCodeDesugar method desugar.
public void desugar(IterableContext ctx) {
// Gather required data for code generation.
processIterableContext(ctx);
// Generate Iterable Iteration.
generateIteratorFunction(ctx);
// Create invocation expression to invoke iterable operation.
final BLangInvocation iExpr = ASTBuilderUtil.createInvocationExpr(ctx.collectionExpr.pos, ctx.iteratorFuncSymbol, Collections.emptyList(), symResolver);
iExpr.requiredArgs.add(ctx.collectionExpr);
if (ctx.getLastOperation().expectedType == symTable.noType || ctx.getLastOperation().expectedType == symTable.voidType) {
ctx.iteratorCaller = iExpr;
} else {
ctx.iteratorCaller = ASTBuilderUtil.wrapToConversionExpr(ctx.getLastOperation().expectedType, iExpr, symTable, types);
}
}
Aggregations