mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 22:02:23 +01:00
Chandler Carruth
01e12111a8
The version of `flake8` was too old to support with Python 3.12 -- there is new F-string support that caused false positives sadly. The updated version has fixes for all of these. This in turn updates codespell which has picked up several new fixes that actually fire in our code, so also fix everything. While we don't do more in-depth updates to old proposals, similar to simply fixing broken links, fixing automatically detected typos seems scalable and fine. All edits were automatically generated here.
191 lines
6.8 KiB
C++
191 lines
6.8 KiB
C++
// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
|
|
// Exceptions. See /LICENSE for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
|
#include "migrate_cpp/rewriter.h"
|
|
|
|
#include <gmock/gmock.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "clang/AST/ASTConsumer.h"
|
|
#include "clang/Frontend/CompilerInstance.h"
|
|
#include "clang/Frontend/FrontendAction.h"
|
|
#include "clang/Tooling/Tooling.h"
|
|
|
|
namespace Carbon::Testing {
|
|
namespace {
|
|
|
|
// Represents C++ source code with at most one region enclosed in $[[...]]$ as
|
|
// an annotated range.
|
|
class Annotations {
|
|
public:
|
|
explicit Annotations(llvm::StringRef annotated_source) {
|
|
size_t index = annotated_source.find("$[[");
|
|
if (index == llvm::StringRef::npos) {
|
|
source_code_ = std::string(annotated_source);
|
|
return;
|
|
}
|
|
start_ = index;
|
|
end_ = annotated_source.find("]]$", index);
|
|
CARBON_CHECK(end_ != llvm::StringRef::npos)
|
|
<< "Found `$[[` but no matching `]]$`";
|
|
source_code_ = (llvm::Twine(annotated_source.substr(0, start_)) +
|
|
annotated_source.substr(start_ + 3, end_ - start_ - 3) +
|
|
annotated_source.substr(end_ + 3))
|
|
.str();
|
|
// Update `end_` so that it is relative to the unannotated source (which
|
|
// means three characters earlier due to the `$[[` being removed.
|
|
end_ -= 3;
|
|
}
|
|
|
|
// Returns a view into the unannotated source.
|
|
auto source() const -> llvm::StringRef { return source_code_; }
|
|
|
|
// Returns the offsets in the file representing the annotated range if they
|
|
// exist and `{0, std::numeric_limits<size_t>::max()}` otherwise.
|
|
auto range() const -> std::pair<size_t, size_t> {
|
|
return std::pair(start_, end_);
|
|
}
|
|
|
|
private:
|
|
std::string source_code_;
|
|
size_t start_ = 0;
|
|
size_t end_ = std::numeric_limits<size_t>::max();
|
|
};
|
|
|
|
// Rewrites the `cpp_code`, return the Carbon equivalent. If the text has no
|
|
// source range annotated with $[[...]]$, the entire translation unit will be
|
|
// migrated and output. Otherwise, only the migrated output corresponding to the
|
|
// annotated range will be be output. No more than one range may be annotated at
|
|
// all.
|
|
//
|
|
// This annotation mechanism is useful in that it allows us to specifically test
|
|
// the migration associated with specific nodes even when they require some
|
|
// additional context that we do not wish to be covered by the test.
|
|
auto RewriteText(llvm::StringRef cpp_code) -> std::string {
|
|
std::string result;
|
|
|
|
Annotations annotated_cpp_code(cpp_code);
|
|
|
|
bool success = clang::tooling::runToolOnCodeWithArgs(
|
|
std::make_unique<MigrationAction>(result, annotated_cpp_code.range()),
|
|
annotated_cpp_code.source(), {}, "test.cc", "clang-tool",
|
|
std::make_shared<clang::PCHContainerOperations>(),
|
|
clang::tooling::FileContentMappings());
|
|
|
|
return success ? result : "";
|
|
}
|
|
|
|
TEST(Rewriter, BoolLiteral) {
|
|
EXPECT_EQ(RewriteText("bool x = $[[true]]$;"), "true");
|
|
EXPECT_EQ(RewriteText("bool x = $[[false]]$;"), "false");
|
|
}
|
|
|
|
TEST(Rewriter, IntegerLiteral) {
|
|
EXPECT_EQ(RewriteText("int x = $[[0]]$;"), "0");
|
|
EXPECT_EQ(RewriteText("int x = $[[1]]$;"), "1");
|
|
EXPECT_EQ(RewriteText("int x = $[[1234]]$;"), "1234");
|
|
EXPECT_EQ(RewriteText("int x = $[[12'34]]$;"), "12_34");
|
|
EXPECT_EQ(RewriteText("int x = $[[12'3'4]]$;"), "12_3_4");
|
|
}
|
|
|
|
TEST(Rewriter, SingleDeclaration) {
|
|
EXPECT_EQ(RewriteText("bool b;"), "var b: bool;\n");
|
|
EXPECT_EQ(RewriteText("int i;"), "var i: i32;\n");
|
|
|
|
EXPECT_EQ(RewriteText("const bool b = false;"), "let b: bool = false;\n");
|
|
EXPECT_EQ(RewriteText("const int i = 17;"), "let i: i32 = 17;\n");
|
|
|
|
EXPECT_EQ(RewriteText("bool const b = false;"), "let b: bool = false;\n");
|
|
EXPECT_EQ(RewriteText("int const i = 1234;"), "let i: i32 = 1234;\n");
|
|
}
|
|
|
|
TEST(Rewriter, Pointers) {
|
|
// TODO: Add tests for pointers-to-const when the syntax is nailed down.
|
|
EXPECT_EQ(RewriteText("bool b;\n"
|
|
"$[[bool *p = &b]]$;"),
|
|
"var p: bool* = &b");
|
|
EXPECT_EQ(RewriteText("bool b;\n"
|
|
"$[[bool * const p = &b]]$;"),
|
|
"let p: bool* = &b");
|
|
|
|
// Pointers and non-pointers on the same DeclStmt.
|
|
EXPECT_EQ(RewriteText("bool b, *p;\n"),
|
|
"var b: bool;\n"
|
|
"var p: bool*;\n");
|
|
EXPECT_EQ(RewriteText("bool b, *p = &b;\n"),
|
|
"var b: bool;\n"
|
|
"var p: bool* = &b;\n");
|
|
}
|
|
|
|
TEST(Rewriter, DeclarationComma) {
|
|
EXPECT_EQ(RewriteText("int x, y;"),
|
|
"var x: i32;\n"
|
|
"var y: i32;\n");
|
|
EXPECT_EQ(RewriteText("int x = 7, y;"),
|
|
"var x: i32 = 7;\n"
|
|
"var y: i32;\n");
|
|
EXPECT_EQ(RewriteText("const int x = 1, y = 2;"),
|
|
"let x: i32 = 1;\n"
|
|
"let y: i32 = 2;\n");
|
|
EXPECT_EQ(RewriteText("int const x = 1234, y = 5678;"),
|
|
"let x: i32 = 1234;\n"
|
|
"let y: i32 = 5678;\n");
|
|
}
|
|
|
|
TEST(Rewriter, FunctionDeclaration) {
|
|
// Function declarations and definitions returning void.
|
|
EXPECT_EQ(RewriteText("void f();"), "fn f() -> ();\n");
|
|
EXPECT_EQ(RewriteText("void f() {}"),
|
|
"fn f() -> () {\n"
|
|
"}\n");
|
|
|
|
// Function declarations and definitions returning int.
|
|
EXPECT_EQ(RewriteText("int f();"), "fn f() -> i32;\n");
|
|
EXPECT_EQ(RewriteText("int f() { return 0; }"),
|
|
"fn f() -> i32 {\n"
|
|
"return 0;\n"
|
|
"}\n");
|
|
|
|
// Function declarations and definitions with a single parameter.
|
|
EXPECT_EQ(RewriteText("int f(bool);"), "fn f(_: bool) -> i32;\n");
|
|
EXPECT_EQ(RewriteText("int f(bool b);"), "fn f(b: bool) -> i32;\n");
|
|
EXPECT_EQ(RewriteText("int f(bool) { return 0; }"),
|
|
"fn f(_: bool) -> i32 {\n"
|
|
"return 0;\n"
|
|
"}\n");
|
|
EXPECT_EQ(RewriteText("int f(bool b) { return 0; }"),
|
|
"fn f(b: bool) -> i32 {\n"
|
|
"return 0;\n"
|
|
"}\n");
|
|
|
|
// Function declarations and definitions with a multiple parameters.
|
|
EXPECT_EQ(RewriteText("int f(bool, int);"),
|
|
"fn f(_: bool, _: i32) -> i32;\n");
|
|
EXPECT_EQ(RewriteText("int f(bool b, int n);"),
|
|
"fn f(b: bool, n: i32) -> i32;\n");
|
|
EXPECT_EQ(RewriteText("int f(bool, int n) { return 0; }"),
|
|
"fn f(_: bool, n: i32) -> i32 {\n"
|
|
"return 0;\n"
|
|
"}\n");
|
|
EXPECT_EQ(RewriteText("int f(bool b, int n) { return 0; }"),
|
|
"fn f(b: bool, n: i32) -> i32 {\n"
|
|
"return 0;\n"
|
|
"}\n");
|
|
EXPECT_EQ(RewriteText("int f(bool b, int n = 3) { return n; }"),
|
|
"fn f(b: bool, n: i32 = 3) -> i32 {\n"
|
|
"return n;\n"
|
|
"}\n");
|
|
|
|
// Function declarations with trailing-return syntax.
|
|
EXPECT_EQ(RewriteText("auto f(bool b, int n = 3) -> int;"),
|
|
"fn f(b: bool, n: i32 = 3) -> i32;\n");
|
|
EXPECT_EQ(RewriteText("auto f(bool b, int n = 3) -> int { return n; }"),
|
|
"fn f(b: bool, n: i32 = 3) -> i32 {\n"
|
|
"return n;\n"
|
|
"}\n");
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace Carbon::Testing
|