func TestGraphs(t *testing.T) {
for _, test := range typeGraphTests {
if os.Getenv("FILTER") != "" && !strings.Contains(test.name, os.Getenv("FILTER")) {
continue
}
fmt.Printf("Running test: %v\n", test.name)
graph, err := compilergraph.NewGraph("tests/" + test.input + "/" + test.entrypoint + ".seru")
if err != nil {
t.Errorf("Got error on test %s: %v", test.name, err)
}
testSRG := srg.NewSRG(graph)
testIDL := webidl.NewIRG(graph)
loader := packageloader.NewPackageLoader(graph.RootSourceFilePath, []string{}, testSRG.PackageLoaderHandler(), testIDL.PackageLoaderHandler())
srgResult := loader.Load(packageloader.Library{TESTLIB_PATH, false, ""})
// Make sure we had no errors during construction.
if !assert.True(t, srgResult.Status, "Got error for SRG construction %v: %s", test.name, srgResult.Errors) {
continue
}
// Construct the type graph.
result := typegraph.BuildTypeGraph(testSRG.Graph, GetConstructor(testSRG), webidltc.GetConstructor(testIDL))
if test.expectedError == "" {
// Make sure we had no errors during construction.
if !assert.True(t, result.Status, "Got error for type graph construction %v: %s", test.name, result.Errors) {
continue
}
currentLayerView := result.Graph.GetFilteredJSONForm(graph.RootSourceFilePath)
if os.Getenv("REGEN") == "true" {
test.writeJson(currentLayerView)
} else {
// Compare the constructed graph layer to the expected.
expectedLayerView := test.json()
assert.Equal(t, expectedLayerView, currentLayerView, "Graph view mismatch on test %s\nExpected: %v\nActual: %v\n\n", test.name, expectedLayerView, currentLayerView)
}
} else {
// Make sure we had an error during construction.
if !assert.False(t, result.Status, "Found no error for type graph construction %v: %s", test.name, result.Errors) {
continue
}
// Make sure the error expected is found.
assert.Equal(t, 1, len(result.Errors), "In test %v: Expected one error, found: %v", test.name, result.Errors)
assert.Equal(t, test.expectedError, result.Errors[0].Error(), "Error mismatch on test %v", test.name)
}
}
}
func getIRG(t *testing.T, path string) *WebIRG {
graph, err := compilergraph.NewGraph(path)
if err != nil {
t.Errorf("%v", err)
}
testIRG := NewIRG(graph)
loader := packageloader.NewPackageLoader(graph.RootSourceFilePath, []string{}, testIRG.PackageLoaderHandler())
result := loader.Load()
if !result.Status {
t.Errorf("Failed to load IRG: %v", result.Errors)
}
return testIRG
}
func loadSRG(t *testing.T, path string, libPaths ...string) (*SRG, packageloader.LoadResult) {
graph, err := compilergraph.NewGraph(path)
if err != nil {
t.Errorf("%v", err)
}
libraries := make([]packageloader.Library, len(libPaths))
for index, libPath := range libPaths {
libraries[index] = packageloader.Library{libPath, false, ""}
}
testSRG := NewSRG(graph)
testLoader := &testTypePackageLoader{graph}
loader := packageloader.NewPackageLoader(graph.RootSourceFilePath, []string{}, testSRG.PackageLoaderHandler(), testLoader)
result := loader.Load(libraries...)
return testSRG, result
}
// ParseAndBuildScopeGraph conducts full parsing and type graph construction for the project
// starting at the given root source file.
func ParseAndBuildScopeGraph(rootSourceFilePath string, vcsDevelopmentDirectories []string, libraries ...packageloader.Library) Result {
graph, err := compilergraph.NewGraph(rootSourceFilePath)
if err != nil {
log.Fatalf("Could not instantiate graph: %v", err)
}
// Create the SRG for the source and load it.
sourcegraph := srg.NewSRG(graph)
webidlgraph := webidl.NewIRG(graph)
loader := packageloader.NewPackageLoader(rootSourceFilePath, vcsDevelopmentDirectories, sourcegraph.PackageLoaderHandler(), webidlgraph.PackageLoaderHandler())
loaderResult := loader.Load(libraries...)
if !loaderResult.Status {
return Result{
Status: false,
Errors: loaderResult.Errors,
Warnings: loaderResult.Warnings,
}
}
// Construct the type graph.
resolver := typerefresolver.NewResolver(sourcegraph)
srgConstructor := srgtc.GetConstructorWithResolver(sourcegraph, resolver)
typeResult := typegraph.BuildTypeGraph(sourcegraph.Graph, srgConstructor, webidltc.GetConstructor(webidlgraph))
if !typeResult.Status {
return Result{
Status: false,
Errors: typeResult.Errors,
Warnings: combineWarnings(loaderResult.Warnings, typeResult.Warnings),
}
}
// Freeze the resolver's cache.
resolver.FreezeCache()
// Construct the scope graph.
scopeResult := buildScopeGraphWithResolver(sourcegraph, webidlgraph, typeResult.Graph, resolver)
return Result{
Status: scopeResult.Status,
Errors: scopeResult.Errors,
Warnings: combineWarnings(loaderResult.Warnings, typeResult.Warnings, scopeResult.Warnings),
Graph: scopeResult.Graph,
}
}
func TestLookupReturnType(t *testing.T) {
graph, err := compilergraph.NewGraph("tests/returntype/returntype.seru")
if !assert.Nil(t, err, "Got graph creation error: %v", err) {
return
}
testSRG := srg.NewSRG(graph)
testIDL := webidl.NewIRG(graph)
loader := packageloader.NewPackageLoader(graph.RootSourceFilePath, []string{}, testSRG.PackageLoaderHandler(), testIDL.PackageLoaderHandler())
srgResult := loader.Load(packageloader.Library{TESTLIB_PATH, false, ""})
if !assert.True(t, srgResult.Status, "Got error for SRG construction: %v", srgResult.Errors) {
return
}
// Construct the type graph.
result := typegraph.BuildTypeGraph(testSRG.Graph, GetConstructor(testSRG), webidltc.GetConstructor(testIDL))
if !assert.True(t, result.Status, "Got error for TypeGraph construction: %v", result.Errors) {
return
}
// Ensure that the function and the property getter have return types.
module, found := testSRG.FindModuleBySource(compilercommon.InputSource("tests/returntype/returntype.seru"))
if !assert.True(t, found, "Could not find source module") {
return
}
resolvedclass, foundClass := module.ResolveTypePath("SomeClass")
if !assert.True(t, foundClass, "Could not find SomeClass") {
return
}
someclass := resolvedclass.ResolvedType.AsType()
// Check the function.
dosomethingFunc, foundFunc := someclass.FindMember("DoSomething")
if !assert.True(t, foundFunc, "Could not find DoSomething") {
return
}
dosomethingFuncReturnType, hasReturnType := result.Graph.LookupReturnType(dosomethingFunc.Node())
if !assert.True(t, hasReturnType, "Could not find return type for DoSomething") {
return
}
assert.Equal(t, "Integer", dosomethingFuncReturnType.String(), "Expected int for DoSomething return type, found: %v", dosomethingFuncReturnType)
// Check the property getter.
someProp, foundProp := someclass.FindMember("SomeProp")
if !assert.True(t, foundProp, "Could not find SomeProp") {
return
}
getter, _ := someProp.Getter()
somePropReturnType, hasPropReturnType := result.Graph.LookupReturnType(getter.GraphNode)
if !assert.True(t, hasPropReturnType, "Could not find return type for SomeProp getter") {
return
}
assert.Equal(t, "SomeClass", somePropReturnType.String(), "Expected SomeClass for SomeProp return type, found: %v", somePropReturnType)
}