1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
package org.zwobble.hobgoblin.compiler;
import org.zwobble.hobgoblin.compiler.ast.typed.TypedNamespaceNode;
import org.zwobble.hobgoblin.compiler.ast.untyped.UntypedNamespaceNode;
import org.zwobble.hobgoblin.compiler.builtins.NativeTypes;
import org.zwobble.hobgoblin.compiler.config.ProjectConfig;
import org.zwobble.hobgoblin.compiler.parser.Parser;
import org.zwobble.hobgoblin.compiler.typechecker.TypeChecker;
import org.zwobble.hobgoblin.compiler.typechecker.TypeCheckerGlobalContext;
import org.zwobble.hobgoblin.compiler.typechecker.errors.UnknownNamespaceError;
import org.zwobble.hobgoblin.compiler.types.NamespaceName;
import org.zwobble.sourcetext.SourceText;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.*;
import java.util.stream.Collectors;
import static org.zwobble.hobgoblin.compiler.typechecker.NamespaceNameResolution.resolveNamespaceName;
public class HobgoblinCompiler {
public static final String FILE_NAME_EXTENSION = ".hob";
private HobgoblinCompiler() {
}
public static void compile(Path projectRoot) throws IOException {
var config = ProjectConfig.read(projectRoot);
var generators = config.createGenerators();
var sourceDirectory = projectRoot.resolve("src");
var sourceFiles = collectSourceFiles(sourceDirectory);
var untypedNamespaceNodes = new ArrayList<UntypedNamespaceNode>();
for (var sourceFile : sourceFiles) {
var namespaceName = sourceFileNamespaceName(sourceDirectory, sourceFile);
var sourceContents = Files.readString(sourceFile, StandardCharsets.UTF_8);
var sourceText = SourceText.fromString(sourceFile.toString(), sourceContents);
var untypedNamespaceNode = Parser.parseNamespace(sourceText, namespaceName);
untypedNamespaceNodes.add(untypedNamespaceNode);
}
var typedNamespaceNodes = new ArrayList<TypedNamespaceNode>();
var typeCheckerContext = TypeCheckerGlobalContext.initial();
typeCheckerContext.addNativeType(NativeTypes.BOOL);
typeCheckerContext.addNativeType(NativeTypes.INT_32);
typeCheckerContext.addNativeType(NativeTypes.INT_64);
typeCheckerContext.addNativeType(NativeTypes.STRING);
typeCheckerContext.addNativeTypeConstructor(NativeTypes.LIST);
typeCheckerContext.addNativeTypeConstructor(NativeTypes.OPTION);
typeCheckerContext.addNativeTypeConstructor(NativeTypes.SHARED);
for (var untypedNamespaceNode : sortUntypedNamespaceNodes(untypedNamespaceNodes)) {
var typedNamespaceNode = TypeChecker.typeCheckNamespace(untypedNamespaceNode, typeCheckerContext);
typedNamespaceNodes.add(typedNamespaceNode);
}
var typesInfo = typeCheckerContext.toTypesInfo();
for (var generator : generators) {
generator.generate(typedNamespaceNodes, typesInfo);
}
}
private static List<UntypedNamespaceNode> sortUntypedNamespaceNodes(List<UntypedNamespaceNode> namespaceNodes) {
var namespaceNodesByName = namespaceNodes.stream()
.collect(Collectors.toMap(node -> node.namespaceName(), node -> node));
var sortedNamespaceNodes = new ArrayList<UntypedNamespaceNode>();
var handledNamespaceNames = new HashSet<NamespaceName>();
var pendingNamespaceNodes = new ArrayDeque<>(namespaceNodes);
while (!pendingNamespaceNodes.isEmpty()) {
var namespaceNode = pendingNamespaceNodes.removeLast();
// TODO: handle cycles
if (!handledNamespaceNames.contains(namespaceNode.namespaceName())) {
var unhandledDependencies = new ArrayList<UntypedNamespaceNode>();
for (var importNode : namespaceNode.imports()) {
var importedNamespaceName = resolveNamespaceName(
namespaceNode.namespaceName(),
importNode.ancestorDepth(),
importNode.namespaceName(),
importNode.source()
);
if (!handledNamespaceNames.contains(importedNamespaceName)) {
unhandledDependencies.add(
Optional.ofNullable(namespaceNodesByName.get(importedNamespaceName))
.orElseThrow(() -> new UnknownNamespaceError(importedNamespaceName, importNode.source()))
);
}
}
if (unhandledDependencies.isEmpty()) {
handledNamespaceNames.add(namespaceNode.namespaceName());
sortedNamespaceNodes.add(namespaceNode);
} else {
pendingNamespaceNodes.add(namespaceNode);
pendingNamespaceNodes.addAll(unhandledDependencies);
}
}
}
return sortedNamespaceNodes;
}
static NamespaceName sourceFileNamespaceName(Path sourceDirectory, Path sourceFilePath) {
var relativePath = sourceDirectory.relativize(sourceFilePath);
var parts = new ArrayList<String>();
for (var i = 0; i < relativePath.getNameCount() - 1; i++) {
parts.add(relativePath.getName(i).toString());
}
var fileName = relativePath.getName(relativePath.getNameCount() - 1).toString();
var lastPart = fileName.substring(0, fileName.length() - FILE_NAME_EXTENSION.length());
parts.add(lastPart);
return new NamespaceName(parts);
}
private static List<Path> collectSourceFiles(
Path sourceRoot
) throws IOException {
var sourceFiles = new ArrayList<Path>();
Files.walkFileTree(sourceRoot, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(
Path file,
BasicFileAttributes attrs
) {
if (file.toString().endsWith(FILE_NAME_EXTENSION)) {
sourceFiles.add(file);
}
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(
Path dir,
IOException exc
) {
return FileVisitResult.CONTINUE;
}
});
sourceFiles.sort(null);
return sourceFiles;
}
}
|
