@Override public String toString() { return this.typeKind.typeName(); }
protected String typeArrayToCode(List<TypeKind> types) { List<String> vals = new ArrayList<>(); for (TypeKind type : types) { vals.add("TypeKind." + type.name()); } return "new TypeKind[] { " + String.join(", ", vals) + " }"; }
@Override public List<CompletionItem> resolveItems(LSServiceOperationContext completionContext) { ArrayList<CompletionItem> completionItems = new ArrayList<>(); BLangNode bLangNode = completionContext.get(CompletionKeys.SYMBOL_ENV_NODE_KEY); BType recordType = bLangNode.type; if (!recordType.getKind().equals(TypeKind.RECORD)) { return completionItems; } List<BField> fields = this.getFieldList((BLangRecordLiteral) bLangNode, completionContext); completionItems.addAll(CommonUtil.getStructFieldCompletionItems(fields)); completionItems.add(CommonUtil.getFillAllStructFieldsItem(fields)); return completionItems; }
private static BType getMessageParamType(List<?> variableNodes) throws GrpcServerException { BType requestType = null; for (Object variable : variableNodes) { if (variable instanceof BLangNode) { BType tempType = ((BLangNode) variable).type; if (tempType.getKind().equals(TypeKind.ARRAY)) { requestType = tempType; break; } // union type and tuple type doesn't have type symbol. If those values pass as response, compiler // failed to derive response message type. Validate and send proper error message. if (tempType.tsymbol == null) { throw new GrpcServerException("Invalid message type. Message type doesn't have type symbol"); } if ("ballerina/grpc:Caller".equals(tempType.tsymbol.toString()) || "ballerina/grpc:Headers" .equals(tempType.tsymbol.toString())) { continue; } requestType = tempType; break; } else { throw new GrpcServerException("Request Message type is not supported, should be lang variable."); } } if (requestType == null) { requestType = new BNilType(); } return requestType; }
@Override public String toString() { return this.typeKind != null ? this.typeKind.typeName() : ""; }
public void visit(BLangTypeDefinition typeDefinition) { if (typeDefinition.typeNode.getKind() == NodeKind.OBJECT_TYPE || typeDefinition.typeNode.getKind() == NodeKind.RECORD_TYPE) { analyzeNode(typeDefinition.typeNode, this.env); } if (!Symbols.isPublic(typeDefinition.symbol) || typeDefinition.symbol.type != null && TypeKind.FINITE.equals(typeDefinition.symbol.type.getKind())) { return; } analyseType(typeDefinition.symbol.type, typeDefinition.pos); }
@Override public String toString() { return getKind().typeName(); }
if (fileEvent.getKind().equals(TypeKind.OBJECT)) { if (fileEvent instanceof BStructureType) { BStructureType event = (BStructureType) fileEvent;
public Name fromTypeKind(TypeKind typeKind) { return fromString(typeKind.typeName()); }
@Override public String getDesc() { switch (tag) { case JSON: case XML: case TABLE: case STREAM: case MAP: case FUTURE: case CHANNEL: return TypeDescriptor.SIG_REFTYPE + getKind().typeName() + ";"; case ANY: return TypeDescriptor.SIG_ANY; case ANYDATA: return TypeDescriptor.SIG_ANYDATA; default: return null; } }
@Override public String toString() { StringJoiner joiner = new StringJoiner(getKind().typeName()); this.memberTypes.stream() .filter(memberType -> memberType.tag != TypeTags.NIL) .forEach(memberType -> joiner.add(memberType.toString())); String typeStr = joiner.toString(); return nullable ? typeStr + Names.QUESTION_MARK.value : typeStr; }
public void visit(BLangRecordLiteral recordLiteral) { List<BLangRecordKeyValue> keyValuePairs = recordLiteral.keyValuePairs; keyValuePairs.forEach(kv -> { analyzeExpr(kv.valueExpr); }); Set<Object> names = new TreeSet<>((l, r) -> l.equals(r) ? 0 : 1); for (BLangRecordKeyValue recFieldDecl : keyValuePairs) { BLangExpression key = recFieldDecl.getKey(); if (key.getKind() == NodeKind.SIMPLE_VARIABLE_REF) { BLangSimpleVarRef keyRef = (BLangSimpleVarRef) key; if (names.contains(keyRef.variableName.value)) { String assigneeType = recordLiteral.parent.type.getKind().typeName(); this.dlog.error(key.pos, DiagnosticCode.DUPLICATE_KEY_IN_RECORD_LITERAL, assigneeType, keyRef); } names.add(keyRef.variableName.value); } else if (key.getKind() == NodeKind.LITERAL) { BLangLiteral keyLiteral = (BLangLiteral) key; if (names.contains(keyLiteral.value)) { String assigneeType = recordLiteral.parent.type.getKind().typeName(); this.dlog.error(key.pos, DiagnosticCode.DUPLICATE_KEY_IN_RECORD_LITERAL, assigneeType, keyLiteral); } names.add(keyLiteral.value); } } }
rootPkgSymbol.pkgID, noType, rootPkgSymbol); initializeType(intType, TypeKind.INT.typeName()); initializeType(byteType, TypeKind.BYTE.typeName()); initializeType(floatType, TypeKind.FLOAT.typeName()); initializeType(decimalType, TypeKind.DECIMAL.typeName()); initializeType(stringType, TypeKind.STRING.typeName()); initializeType(booleanType, TypeKind.BOOLEAN.typeName()); initializeType(typeDesc, TypeKind.TYPEDESC.typeName()); initializeType(jsonType, TypeKind.JSON.typeName()); initializeType(xmlType, TypeKind.XML.typeName()); initializeType(tableType, TypeKind.TABLE.typeName()); initializeType(streamType, TypeKind.STREAM.typeName()); initializeType(mapType, TypeKind.MAP.typeName()); initializeType(mapStringType, TypeKind.MAP.typeName()); initializeType(mapAnydataType, TypeKind.MAP.typeName()); initializeType(futureType, TypeKind.FUTURE.typeName()); initializeType(anyType, TypeKind.ANY.typeName()); initializeType(anydataType, TypeKind.ANYDATA.typeName()); initializeType(nilType, TypeKind.NIL.typeName()); initializeType(channelType, TypeKind.CHANNEL.typeName()); initializeType(anyServiceType, TypeKind.SERVICE.typeName());
public Builder setType(BType type) throws GrpcServerException { if (type == null || type.tsymbol == null) { throw new GrpcServerException("Unsupported field type, field type without symbol is not supported."); } fieldType = BALLERINA_TO_PROTO_MAP.get(type.tsymbol.name.value) != null ? BALLERINA_TO_PROTO_MAP.get(type .tsymbol.name.value) : type.tsymbol.name.value; DescriptorProtos.FieldDescriptorProto.Type primType = STRING_TYPE_MAP.get(fieldType); if (primType != null) { fieldDescriptorBuilder.setType(primType); } else { if (type instanceof BStructureType || type instanceof FiniteType) { fieldDescriptorBuilder.setTypeName(fieldType); } else { throw new GrpcServerException("Unsupported field type, field type " + type.getKind().typeName() + " currently not supported."); } } return this; }
private static void setMeta(CompletionItem item, BVarSymbol bSymbol) { if (bSymbol == null) { item.setKind(CompletionItemKind.Variable); return; } //Or, else if ((bSymbol.flags & Flags.FINAL) == Flags.FINAL) { if (bSymbol.type.tsymbol != null && TypeKind.STRING.typeName().equals(bSymbol.type.tsymbol.name.value)) { // string final item.setKind(CompletionItemKind.Text); } else { // non-string final item.setKind(CompletionItemKind.Unit); } } else { // variables item.setKind(CompletionItemKind.Variable); } if (bSymbol.markdownDocumentation != null) { item.setDocumentation(bSymbol.markdownDocumentation.description); } } }
private BType checkStructFieldAccess(BLangVariableReference varReferExpr, Name fieldName, BType structType) { BSymbol fieldSymbol = symResolver.resolveStructField(varReferExpr.pos, this.env, fieldName, structType.tsymbol); if (fieldSymbol != symTable.notFoundSymbol) { // Setting the field symbol. This is used during the code generation phase varReferExpr.symbol = fieldSymbol; return fieldSymbol.type; } if (structType.tag == TypeTags.OBJECT) { // check if it is an attached function pointer call Name objFuncName = names.fromString(Symbols.getAttachedFuncSymbolName(structType.tsymbol.name.value, fieldName.value)); fieldSymbol = symResolver.resolveObjectField(varReferExpr.pos, env, objFuncName, structType.tsymbol); if (fieldSymbol == symTable.notFoundSymbol) { dlog.error(varReferExpr.pos, DiagnosticCode.UNDEFINED_STRUCTURE_FIELD, fieldName, structType.tsymbol.type.getKind().typeName(), structType.tsymbol); return symTable.semanticError; } // Setting the field symbol. This is used during the code generation phase varReferExpr.symbol = fieldSymbol; return fieldSymbol.type; } // Assuming this method is only used for objects and records if (((BRecordType) structType).sealed) { dlog.error(varReferExpr.pos, DiagnosticCode.UNDEFINED_STRUCTURE_FIELD, fieldName, structType.tsymbol.type.getKind().typeName(), structType.tsymbol); return symTable.semanticError; } return ((BRecordType) structType).restFieldType; }
private BType checkStructLiteralKeyExpr(BLangRecordKey key, BType recordType) { Name fieldName; BLangExpression keyExpr = key.expr; if (keyExpr.getKind() == NodeKind.SIMPLE_VARIABLE_REF) { BLangSimpleVarRef varRef = (BLangSimpleVarRef) keyExpr; fieldName = names.fromIdNode(varRef.variableName); } else { // keys of the struct literal can only be a varRef (identifier) dlog.error(keyExpr.pos, DiagnosticCode.INVALID_RECORD_LITERAL_KEY); return symTable.semanticError; } // Check whether the struct field exists BSymbol fieldSymbol = symResolver.resolveStructField(keyExpr.pos, this.env, fieldName, recordType.tsymbol); if (fieldSymbol == symTable.notFoundSymbol) { if (((BRecordType) recordType).sealed) { dlog.error(keyExpr.pos, DiagnosticCode.UNDEFINED_STRUCTURE_FIELD, fieldName, recordType.tsymbol.type.getKind().typeName(), recordType.tsymbol); return symTable.semanticError; } return ((BRecordType) recordType).restFieldType; } return fieldSymbol.type; }
/** * Build a readable parameter model from a Ballerina <code>VariableNode</code>. * * @param parameter {@code VariableNode} with parameter definition * @return built Parameter context model */ public static ParameterContextHolder buildContext(VariableNode parameter) { ParameterContextHolder context = new ParameterContextHolder(); TypeNode type = parameter.getTypeNode(); if (type instanceof BLangValueType) { context.type = ((BLangValueType) parameter.getTypeNode()).getTypeKind().typeName(); } else if (type instanceof BLangUserDefinedType) { context.type = ((BLangUserDefinedType) parameter.getTypeNode()).getTypeName().getValue(); } // Ignore Connection and InRequest parameters if (context.isIgnoredType(context.type)) { return null; } context.name = parameter.getName().toString(); context.defaultValue = context.getDefaultValue(context.type, context.name); // examples are not yet supported context.example = ""; return context; }
private void defineInitFunctionParam(BLangSimpleVariable varNode) { Name varName = names.fromIdNode(varNode.name); // Here it is assumed that initFunctions are always for objects. BLangObjectTypeNode objectTypeNode = (BLangObjectTypeNode) env.enclType; BTypeSymbol objectTypeSumbol = objectTypeNode.type.tsymbol; BSymbol fieldSymbol = symResolver.resolveObjectField(varNode.pos, env, varName, objectTypeSumbol); if (fieldSymbol == symTable.notFoundSymbol) { dlog.error(varNode.pos, DiagnosticCode.UNDEFINED_STRUCTURE_FIELD, varName, env.enclType.type.getKind().typeName(), env.enclType.type.tsymbol.name); } // Define a new symbol for the constructor param, with the same type as the object field. varNode.type = fieldSymbol.type; BVarSymbol paramSymbol; if (fieldSymbol.kind == SymbolKind.FUNCTION) { paramSymbol = ASTBuilderUtil.duplicateInvokableSymbol((BInvokableSymbol) fieldSymbol, objectTypeNode.initFunction.symbol, fieldSymbol.name, objectTypeSumbol.pkgID); } else { paramSymbol = new BVarSymbol(Flags.asMask(varNode.flagSet), varName, env.enclPkg.symbol.pkgID, varNode.type, env.scope.owner); } defineShadowedSymbol(varNode.pos, paramSymbol, env); // Create an assignment to the actual field. // i.e.: self.x = x objectTypeNode.initFunction.initFunctionStmts.put(fieldSymbol, (BLangStatement) createAssignmentStmt(varNode, paramSymbol, fieldSymbol)); varNode.symbol = paramSymbol; return; }
.typeName() + " currently not supported.");