blob: 5ffbe47af2489b507eafa9042506b6d0e6963ca0 [file] [log] [blame]
// Copyright 2024 The Dawn & Tint Authors
//
// 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.
//
// 3. Neither the name of the copyright holder nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT HOLDER 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.
#include <string_view>
#include "src/tint/lang/core/constant/scalar.h"
#include "src/tint/lang/core/constant/splat.h"
#include "src/tint/lang/core/constant/value.h"
#include "src/tint/lang/core/type/void.h"
#include "src/tint/lang/wgsl/ast/const.h"
#include "src/tint/lang/wgsl/ast/identifier.h"
#include "src/tint/lang/wgsl/ast/identifier_expression.h"
#include "src/tint/lang/wgsl/ast/let.h"
#include "src/tint/lang/wgsl/ast/member_accessor_expression.h"
#include "src/tint/lang/wgsl/ast/override.h"
#include "src/tint/lang/wgsl/ast/templated_identifier.h"
#include "src/tint/lang/wgsl/ast/var.h"
#include "src/tint/lang/wgsl/ls/server.h"
#include "src/tint/lang/wgsl/ls/utils.h"
#include "src/tint/lang/wgsl/sem/behavior.h"
#include "src/tint/lang/wgsl/sem/builtin_enum_expression.h"
#include "src/tint/lang/wgsl/sem/builtin_fn.h"
#include "src/tint/lang/wgsl/sem/call.h"
#include "src/tint/lang/wgsl/sem/call_target.h"
#include "src/tint/lang/wgsl/sem/function.h"
#include "src/tint/lang/wgsl/sem/function_expression.h"
#include "src/tint/lang/wgsl/sem/load.h"
#include "src/tint/lang/wgsl/sem/materialize.h"
#include "src/tint/lang/wgsl/sem/member_accessor_expression.h"
#include "src/tint/lang/wgsl/sem/struct.h"
#include "src/tint/lang/wgsl/sem/type_expression.h"
#include "src/tint/lang/wgsl/sem/variable.h"
#include "src/tint/utils/rtti/switch.h"
#include "src/tint/utils/text/string_stream.h"
using namespace tint::core::fluent_types; // NOLINT
namespace lsp = langsvr::lsp;
namespace tint::wgsl::ls {
namespace {
lsp::MarkedStringWithLanguage WGSL(std::string wgsl) {
lsp::MarkedStringWithLanguage str;
str.language = "wgsl";
str.value = wgsl;
return str;
}
void PrintConstant(const core::constant::Value* val, StringStream& ss) {
Switch(
val, //
[&](const core::constant::Scalar<AInt>* s) { ss << s->value; },
[&](const core::constant::Scalar<AFloat>* s) { ss << s->value; },
[&](const core::constant::Scalar<bool>* s) { ss << s->value; },
[&](const core::constant::Scalar<f16>* s) { ss << s->value << "h"; },
[&](const core::constant::Scalar<f32>* s) { ss << s->value << "f"; },
[&](const core::constant::Scalar<i32>* s) { ss << s->value << "i"; },
[&](const core::constant::Scalar<u32>* s) { ss << s->value << "u"; },
[&](const core::constant::Splat* s) {
ss << s->Type()->FriendlyName() << "(";
PrintConstant(s->el, ss);
ss << ")";
},
[&](const core::constant::Composite* s) {
ss << s->Type()->FriendlyName() << "(";
for (size_t i = 0, n = s->elements.Length(); i < n; i++) {
if (i > 0) {
ss << ", ";
}
PrintConstant(s->elements[i], ss);
}
ss << ")";
});
}
void Variable(const sem::Variable* v, std::vector<lsp::MarkedString>& out) {
StringStream ss;
auto* kind = Switch(
v->Declaration(), //
[&](const ast::Var*) { return "var"; }, //
[&](const ast::Let*) { return "let"; }, //
[&](const ast::Const*) { return "const"; }, //
[&](const ast::Override*) { return "override"; });
if (kind) {
ss << kind << " ";
}
ss << v->Declaration()->name->symbol.NameView() << " : "
<< v->Type()->UnwrapRef()->FriendlyName();
if (auto* init = v->Initializer()) {
if (auto* val = init->ConstantValue()) {
ss << " = ";
PrintConstant(val, ss);
}
}
out.push_back(WGSL(ss.str()));
}
void Function(const sem::Function* f, std::vector<lsp::MarkedString>& out) {
StringStream ss;
ss << "fn " << f->Declaration()->name->symbol.NameView();
ss << "(";
bool first = true;
for (auto* param : f->Parameters()) {
if (!first) {
ss << ", ";
}
first = false;
ss << param->Declaration()->name->symbol.NameView() << " : "
<< param->Type()->FriendlyName();
}
ss << ")";
if (auto* ret = f->ReturnType(); !ret->Is<core::type::Void>()) {
ss << " -> " << ret->FriendlyName();
}
out.push_back(WGSL(ss.str()));
}
void Call(std::string_view name, const sem::Call* c, std::vector<lsp::MarkedString>& out) {
StringStream ss;
ss << name << "(";
bool first = true;
for (auto* param : c->Target()->Parameters()) {
if (!first) {
ss << ", ";
}
first = false;
if (auto* decl = param->Declaration()) {
ss << decl->name->symbol.NameView() << " : ";
} else if (auto usage = param->Usage(); usage != core::ParameterUsage::kNone) {
ss << param->Usage() << " : ";
}
ss << param->Type()->FriendlyName();
}
ss << ")";
if (auto* ret = c->Target()->ReturnType(); !ret->Is<core::type::Void>()) {
ss << " -> " << ret->FriendlyName();
}
out.push_back(WGSL(ss.str()));
}
void Constant(const core::constant::Value* val, std::vector<lsp::MarkedString>& out) {
StringStream ss;
PrintConstant(val, ss);
out.push_back(WGSL(ss.str()));
}
} // namespace
typename lsp::TextDocumentHoverRequest::ResultType //
Server::Handle(const lsp::TextDocumentHoverRequest& r) {
auto file = files_.Get(r.text_document.uri);
if (!file) {
return lsp::Null{};
}
auto* node = (*file)->NodeAt<CastableBase, File::UnwrapMode::kNoUnwrap>(Conv(r.position));
if (!node) {
return lsp::Null{};
}
std::vector<lsp::MarkedString> strings;
if (auto* materialize = node->As<sem::Materialize>()) {
if (auto* val = materialize->ConstantValue()) {
Constant(val, strings);
lsp::Hover hover;
hover.contents = std::move(strings);
hover.range = Conv(materialize->Declaration()->source.range);
return hover;
}
}
langsvr::Optional<lsp::Range> range;
Switch(
Unwrap(node), //
[&](const sem::VariableUser* user) {
Variable(user->Variable(), strings);
range = Conv(user->Declaration()->source.range);
},
[&](const sem::Variable* v) {
Variable(v, strings);
range = Conv(v->Declaration()->name->source.range);
},
[&](const sem::Call* c) {
Call(c->Declaration()->target->identifier->symbol.NameView(), c, strings);
range = Conv(c->Declaration()->target->source.range);
},
[&](const sem::FunctionExpression* expr) {
Function(expr->Function(), strings);
range = Conv(expr->Declaration()->source.range);
},
[&](const sem::BuiltinEnumExpression<wgsl::BuiltinFn>* fn) {
if (auto* call = (*file)->NodeAt<sem::Call>(Conv(r.position))) {
Call(str(fn->Value()), call, strings);
} else {
strings.push_back(WGSL(str(fn->Value())));
}
range = Conv(fn->Declaration()->source.range);
},
[&](const sem::TypeExpression* expr) {
Switch(
expr->Type(), //
[&](const sem::Struct* str) {
strings.push_back(WGSL("struct " + str->Name().Name()));
},
[&](Default) { strings.push_back(WGSL(expr->Type()->FriendlyName())); });
range = Conv(expr->Declaration()->source.range);
},
[&](const sem::StructMemberAccess* access) {
if (auto* member = access->Member()->As<sem::StructMember>()) {
StringStream ss;
ss << member->Declaration()->name->symbol.NameView() << " : "
<< member->Type()->FriendlyName();
strings.push_back(WGSL(ss.str()));
range = Conv(access->Declaration()->member->source.range);
}
},
[&](const sem::ValueExpression* expr) {
if (auto* val = expr->ConstantValue()) {
Constant(val, strings);
range = Conv(expr->Declaration()->source.range);
}
});
if (strings.empty()) {
return lsp::Null{};
}
lsp::Hover hover;
hover.contents = std::move(strings);
hover.range = std::move(range);
return hover;
}
} // namespace tint::wgsl::ls