ember/module_summary_env.go at main · besmpl/ember · GitHub

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
package ember

type moduleSummaryEnv struct {
	summaries map[string]ModuleSummary
}

func moduleSummaryEnvFromMap(summaries map[string]ModuleSummary) moduleSummaryEnv {
	env := moduleSummaryEnv{summaries: make(map[string]ModuleSummary, len(summaries)*2)}
	for key, summary := range summaries {
		clone := cloneModuleSummary(summary)
		if key != "" {
			env.summaries[key] = clone
		}
		if summary.SourceName != "" {
			env.summaries[summary.SourceName] = clone
			if parsed, err := parseModuleKey(summary.SourceName); err == nil {
				env.summaries[parsed.String()] = clone
			}
		}
	}
	return env
}

func (e moduleSummaryEnv) returnExportForRequire(from Source, request string) (ModuleExport, bool) {
	summary, ok := e.summaryForRequire(from, request)
	if !ok {
		return ModuleExport{}, false
	}
	return moduleExportByNameKind(summary.Exports, "return", ModuleExportValue)
}

func (e moduleSummaryEnv) active() bool {
	return e.summaries != nil
}

func (e moduleSummaryEnv) summaryForRequire(from Source, request string) (ModuleSummary, bool) {
	if e.summaries == nil {
		return ModuleSummary{}, false
	}
	fromKey, err := parseModuleKey(from.Name)
	if err != nil {
		return ModuleSummary{}, false
	}
	required, err := normalizeRequireKey(fromKey, request)
	if err != nil {
		return ModuleSummary{}, false
	}
	summary, ok := e.summaries[required.String()]
	if !ok {
		summary, ok = e.summaries[required.path]
	}
	if !ok {
		return ModuleSummary{}, false
	}
	return summary, true
}

func (e moduleSummaryEnv) staleDependency(summary ModuleSummary) (ModuleDependencySummary, bool) {
	for _, dependency := range summary.Dependencies {
		if dependency.InvalidationHash == "" {
			continue
		}
		current, ok := e.summaryForDependency(dependency)
		if !ok || current.InvalidationHash == "" {
			continue
		}
		if current.InvalidationHash != dependency.InvalidationHash {
			return dependency, true
		}
	}
	return ModuleDependencySummary{}, false
}

func (e moduleSummaryEnv) summaryForDependency(dependency ModuleDependencySummary) (ModuleSummary, bool) {
	if e.summaries == nil {
		return ModuleSummary{}, false
	}
	for _, key := range []string{dependency.Key, dependency.Path} {
		if key == "" {
			continue
		}
		if summary, ok := e.summaries[key]; ok {
			return summary, true
		}
	}
	return ModuleSummary{}, false
}

func cloneModuleSummary(summary ModuleSummary) ModuleSummary {
	clone := summary
	clone.Exports = make([]ModuleExport, len(summary.Exports))
	for i, export := range summary.Exports {
		clone.Exports[i] = export
		clone.Exports[i].Type = cloneTypeSummary(export.Type)
		clone.Exports[i].DiagCodes = append([]string(nil), export.DiagCodes...)
	}
	clone.Dependencies = append([]ModuleDependencySummary(nil), summary.Dependencies...)
	clone.Diagnostics = append([]Diagnostic(nil), summary.Diagnostics...)
	return clone
}