introduce VirtualFileGist and PsiFileGist
[idea/community.git] / java / java-analysis-impl / src / com / intellij / codeInspection / dataFlow / MethodDataExternalizer.kt
1 /*
2  * Copyright 2000-2016 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.codeInspection.dataFlow
17
18 import com.intellij.util.io.DataExternalizer
19 import com.intellij.util.io.DataInputOutputUtil
20 import com.intellij.util.io.IOUtil
21 import java.io.DataInput
22 import java.io.DataOutput
23
24 /**
25  * @author peter
26  */
27 internal object MethodDataExternalizer : DataExternalizer<MethodData> {
28
29   override fun save(out: DataOutput, data: MethodData) {
30     writeNullable(out, data.nullity) { writeNullity(out, it) }
31     writeNullable(out, data.purity) { writePurity(out, it) }
32     writeList(out, data.contracts) { writeContract(out, it) }
33     DataInputOutputUtil.writeINT(out, data.bodyStart)
34     DataInputOutputUtil.writeINT(out, data.bodyEnd)
35   }
36
37   override fun read(input: DataInput): MethodData {
38     val nullity = readNullable(input) { readNullity(input) }
39     val purity = readNullable(input) { readPurity(input) }
40     val contracts = readList(input) { readContract(input) }
41     return MethodData(nullity, purity, contracts, DataInputOutputUtil.readINT(input), DataInputOutputUtil.readINT(input))
42   }
43
44   private fun writeNullity(out: DataOutput, nullity: NullityInferenceResult) = when (nullity) {
45     is NullityInferenceResult.Predefined -> { out.writeByte(0); out.writeByte(nullity.value.ordinal) }
46     is NullityInferenceResult.FromDelegate -> { out.writeByte(1); writeRanges(out, nullity.delegateCalls) }
47     else -> throw IllegalArgumentException(nullity.toString())
48   }
49   private fun readNullity(input: DataInput): NullityInferenceResult = when (input.readByte().toInt()) {
50     0 -> NullityInferenceResult.Predefined(Nullness.values()[input.readByte().toInt()])
51     else -> NullityInferenceResult.FromDelegate(readRanges(input))
52   }
53
54   private fun writeRanges(out: DataOutput, ranges: List<ExpressionRange>) = writeList(out, ranges) { writeRange(out, it) }
55   private fun readRanges(input: DataInput) = readList(input) { readRange(input) }
56
57   private fun writeRange(out: DataOutput, range: ExpressionRange) {
58     DataInputOutputUtil.writeINT(out, range.startOffset)
59     DataInputOutputUtil.writeINT(out, range.endOffset)
60   }
61   private fun readRange(input: DataInput) = ExpressionRange(DataInputOutputUtil.readINT(input), DataInputOutputUtil.readINT(input))
62
63   private fun writePurity(out: DataOutput, purity: PurityInferenceResult) {
64     writeRanges(out, purity.mutatedRefs)
65     writeNullable(out, purity.singleCall) { writeRange(out, it) }
66   }
67   private fun readPurity(input: DataInput) = PurityInferenceResult(readRanges(input), readNullable(input) { readRange(input) })
68
69   private fun writeContract(out: DataOutput, contract: PreContract): Unit = when (contract) {
70     is DelegationContract -> { out.writeByte(0); writeRange(out, contract.expression); out.writeBoolean(contract.negated) }
71     is KnownContract -> { out.writeByte(1);
72       writeContractArguments(out, contract.contract.arguments.toList())
73       out.writeByte(contract.contract.returnValue.ordinal)
74     }
75     is MethodCallContract -> { out.writeByte(2);
76       writeRange(out, contract.call);
77       writeList(out, contract.states) { writeContractArguments(out, it) }
78     }
79     is NegatingContract -> { out.writeByte(3); writeContract(out, contract.negated) }
80     is SideEffectFilter -> { out.writeByte(4);
81       writeRanges(out, contract.expressionsToCheck)
82       writeList(out, contract.contracts) { writeContract(out, it) }
83     }
84     else -> throw IllegalArgumentException(contract.toString())
85   }
86   private fun readContract(input: DataInput): PreContract = when (input.readByte().toInt()) {
87     0 -> DelegationContract(readRange(input), input.readBoolean())
88     1 -> KnownContract(MethodContract(readContractArguments(input).toTypedArray(), readValueConstraint(input)))
89     2 -> MethodCallContract(readRange(input), readList(input) { readContractArguments(input) })
90     3 -> NegatingContract(readContract(input))
91     else -> SideEffectFilter(readRanges(input), readList(input) { readContract(input) })
92   }
93
94   private fun writeContractArguments(out: DataOutput, arguments: List<MethodContract.ValueConstraint>) =
95       writeList(out, arguments) { out.writeByte(it.ordinal) }
96   private fun readContractArguments(input: DataInput) = readList(input, { readValueConstraint(input) })
97
98   private fun readValueConstraint(input: DataInput) = MethodContract.ValueConstraint.values()[input.readByte().toInt()]
99
100 }
101
102 // utils
103
104 private fun <T> writeNullable(out: DataOutput, value: T?, writeItem: (T) -> Unit) = when (value) {
105   null -> out.writeBoolean(false)
106   else -> { out.writeBoolean(true); writeItem(value) }
107 }
108 private fun <T> readNullable(input: DataInput, readEach: () -> T): T? = if (input.readBoolean()) readEach() else null
109
110 private fun <T> writeList(out: DataOutput, list: List<T>, writeEach: (T) -> Unit) {
111   DataInputOutputUtil.writeINT(out, list.size)
112   list.forEach(writeEach)
113 }
114 private fun <T> readList(input: DataInput, readEach: () -> T) = (0 until DataInputOutputUtil.readINT(input)).map { readEach() }