If you're asking about documentation, I'd suggest you check out Jazzy, a tool for building documentation from your inline code comments. It's nice way to build stand-alone documentation from your code comments and it's consistent with Apple's conventions.
The basic convention that uses is as follows. Let's imagine that you have some class defined like follows:
/// Some incredibly useful class
public class MyClass {
/// Performs some foo-like operation
///
/// - Parameter bar: The bar parameter.
public class func foo(_ bar: String) {
// do something
}
/// Some bazzy operation
///
/// - Parameter qux: The bar parameter.
public func baz(_ quz: String) {
// do something
}
}
Jazzy will generates documentation that looks like:
Note, it's just showing you the argument labels. If you tap on one, it shows you whether it's a type method and what the parameter names are:
In the original question it wasn't clear you were talking about documentation, so I discussed the conventions one encounters in code. That answer is below.
In Swift, it's . for both instance and property types.
It's simply a matter of what preceeds the .. If it is a type, it's a type property/method. Consider:
let b = Foo.bar
This is referencing type property bar for Foo type. But if what preceeds the . is an instance of a type, then you're dealing with an instance property/method. Consider:
let b = Baz()
let q = baz.qux
In this case, qux is referencing an instance property of Baz, because b an instance of the Baz type.
At the risk of clouding the issue, a caveat to the above pattern is the use of "selectors" (an older Objective-C pattern) in Swift. In this case the choice of target indicates what the selector references. If you supply an instance for target, the selector is referencing an instance method. If you supply a type for the target, then the selector is referencing a type method. Thus, in this example, the selector is referencing an instance method:
Timer.scheduledTimer(timeInterval: 1, target: self, selector: #selector(ViewController.foo), userInfo: nil, repeats: false)
Whereas the following will call a type method:
Timer.scheduledTimer(timeInterval: 1, target: ViewController.self, selector: #selector(ViewController.foo), userInfo: nil, repeats: false)
Note, in both of these two examples, if we're interacting within the same class, we generally omit the class name altogether. You only have to explicitly reference the type if it's in another class. But I include this target/selector pattern merely because it does show another, slightly different, use of the Class.method syntax.
But this exception is unique. The general pattern is xxx.yyy where if xxx is an instance of some type, then yyy is an instance property/method, whereas if xxx is the name of some type, then yyy is a type property/method.
The references of append(_ newElement:) as append(_:) is completely different thing. This is just a case where the first parameter, newElement has no external label, so it's called with no label, e.g. array.append(object). So append(_:) is just a notation that shows you how it's called (where we don't care what the internal parameter name is), but append(_ newElement:) is how it's implemented (where we do want to know how to refer to this parameter within the method).
